Wie nutzt man Python für die statistische Auswertung einer Abschlussarbeit?

Warum Python für die Abschlussarbeit?

Python hat sich in der empirischen Wissenschaft als vollwertige Alternative zu SPSS oder Stata etabliert – und für bestimmte Aufgaben ist es diesen Programmen sogar überlegen. Der entscheidende Vorteil: Ihre gesamte Auswertung liegt als lesbares Skript oder Jupyter Notebook vor, das jederzeit nachvollzogen, ergänzt und reproduziert werden kann.

Gerade für Abschlussarbeiten ist das relevant. Wenn Ihre Betreuerin oder Ihr Betreuer nach einem bestimmten Schritt fragt oder Sie eine Analyse kurzfristig anpassen müssen, öffnen Sie einfach das Skript und ändern die entsprechende Zeile – kein Klicken durch Menüs, keine manuelle Dokumentation einzelner Schritte. Wer sich fragt, warum Python dabei Excel klar überlegen ist, findet dort einen direkten Vergleich beider Ansätze.

Python ist kostenlos, plattformübergreifend und wird aktiv weiterentwickelt. Für den akademischen Einstieg brauchen Sie kein tiefes Programmierwissen – mit den richtigen Paketen sind gängige statistische Auswertungen in wenigen Zeilen Code erledigt.

Die richtigen Pakete für statistische Auswertungen

Python besteht statistisch gesehen nicht aus einem einzigen Programm, sondern aus einem Ökosystem aufeinander abgestimmter Bibliotheken. Das Modul scipy.stats deckt dabei Wahrscheinlichkeitsverteilungen, klassische Hypothesentests, Korrelationsfunktionen und Kerndichteschätzungen ab – alles, was in einer typischen Abschlussarbeit für inferenzstatistische Standardfragen benötigt wird.

Die Rollenverteilung der wichtigsten Pakete sieht in der Praxis so aus:

Diese Aufteilung ist kein Zufall: Die offizielle SciPy-Dokumentation empfiehlt statsmodels explizit für Regressionsmodelle und lineare Modelle, während scipy.stats für klassische Tests zuständig ist. Mehr zu den einzelnen Python-Tools und ihrer spezifischen Rolle in der Datenanalyse erfahren Sie in einem gesonderten Beitrag.

Der Analyse-Workflow in drei Phasen

Ein häufiger Fehler bei Abschlussarbeiten: Man springt direkt zu den Tests und vernachlässigt Struktur und Dokumentation. Wissenschaftliche Datenanalyse folgt idealerweise einem reproduzierbaren Workflow in drei Phasen – Explore, Refine und Produce – bei dem nicht nur Funktionen, sondern auch Dateistruktur, Skripte, Plausibilitätsprüfungen und Dokumentation eine Rolle spielen.

Übertragen auf eine Abschlussarbeit bedeutet das:

• Explore: Daten einlesen, kennenlernen, bereinigen, erste Visualisierungen und deskriptive Kennzahlen erstellen, verschiedene Analyseansätze ausprobieren.
• Refine: Entscheidung für die finalen Methoden, Code ordnen und kommentieren, Ergebnisse in eine nachvollziehbare Argumentation überführen.
• Produce: Finale Tabellen, Abbildungen und Ausgaben exportieren, Skript so dokumentieren, dass es vollständig reproduzierbar ist.

Eine ausführlichere Beschreibung der sechs Schritte der Datenanalyse hilft Ihnen, diesen Prozess von Anfang an strukturiert anzugehen.

Daten laden und aufbereiten

Der erste Schritt jeder Auswertung ist das Einlesen der Rohdaten. In den meisten Abschlussarbeiten liegen diese als CSV- oder Excel-Datei vor – etwa aus einem Online-Fragebogen, einer Datenbank oder einer Messsoftware.

import pandas as pd
import numpy as np
from scipy import stats
import statsmodels.formula.api as smf
import matplotlib.pyplot as plt
import seaborn as sns

# Daten einlesen
df = pd.read_csv("daten_abschlussarbeit.csv")

# Erste Übersicht
print(df.shape)        # Zeilen × Spalten
print(df.dtypes)       # Datentypen prüfen
print(df.head())       # Erste Zeilen anzeigen
print(df.isnull().sum())  # Fehlende Werte zählen

Wie Sie CSV- und Excel-Daten in Python importieren – inklusive typischer Sonderfälle wie Trennzeichen, Encoding oder Datumsspalten – ist in einem eigenen Beitrag ausführlich beschrieben.

Daten bereinigen und transformieren

Vor jeder Analyse müssen Sie sicherstellen, dass Ihre Daten vollständig und konsistent sind. Fehlende Werte, falsche Datentypen oder Ausreißer verfälschen sonst alle nachfolgenden Ergebnisse.

# Fehlende Werte behandeln
df = df.dropna(subset=["alter", "testergebnis"])  # Zeilen mit NaN entfernen
# Alternativ: df["einkommen"].fillna(df["einkommen"].median(), inplace=True)

# Datentypen korrigieren
df["gruppe"] = df["gruppe"].astype("category")
df["alter"] = pd.to_numeric(df["alter"], errors="coerce")

# Ausreißer identifizieren (z-Score-Methode)
df["z_testergebnis"] = stats.zscore(df["testergebnis"])
ausreisser = df[df["z_testergebnis"].abs() > 3]
print(f"Ausreißer: {len(ausreisser)} Fälle")

Einen tieferen Einblick in den Umgang mit fehlenden Werten in Python – von einfacher Listwise Deletion bis zur multiplen Imputation – bietet ein gesonderter Beitrag.

Deskriptive Statistik berechnen

Bevor Sie inferenzstatistische Tests durchführen, beschreiben Sie Ihre Stichprobe. Das ist nicht nur methodisch sauber, sondern in fast allen Hochschulrichtlinien für Abschlussarbeiten explizit gefordert.

# Überblick über alle numerischen Variablen
print(df.describe())

# Kennzahlen für einzelne Variablen
print(f"Mittelwert Alter: {df['alter'].mean():.2f}")
print(f"Standardabweichung Alter: {df['alter'].std():.2f}")
print(f"Median Testergebnis: {df['testergebnis'].median():.2f}")

# Häufigkeiten für kategoriale Variablen
print(df["gruppe"].value_counts())
print(df["gruppe"].value_counts(normalize=True).round(3))  # Anteile

Die pandas-Bibliothek übernimmt dabei die gesamte Datenverwaltung. Wie Datenanalyse mit pandas im Detail funktioniert, von der Auswahl von Spalten bis zur Gruppierung, ist ausführlich dokumentiert.

Inferenzstatistische Tests durchführen

Der Kern der meisten empirischen Abschlussarbeiten: Hypothesen testen. Python bietet über scipy.stats alle gängigen Verfahren – von Gruppenvergleichen über Korrelationen bis zu Verteilungstests.

t-Test für zwei unabhängige Gruppen

from scipy import stats

gruppe_a = df[df["gruppe"] == "Experimental"]["testergebnis"]
gruppe_b = df[df["gruppe"] == "Kontrolle"]["testergebnis"]

# Varianzhomogenität prüfen (Levene-Test)
levene_stat, levene_p = stats.levene(gruppe_a, gruppe_b)
print(f"Levene-Test: W = {levene_stat:.3f}, p = {levene_p:.3f}")

# t-Test (Welch-Variante, robust bei ungleichen Varianzen)
t_stat, p_wert = stats.ttest_ind(gruppe_a, gruppe_b, equal_var=False)
print(f"t = {t_stat:.3f}, p = {p_wert:.3f}")

# Effektstärke Cohen's d
n_a, n_b = len(gruppe_a), len(gruppe_b)
pooled_std = np.sqrt(((n_a - 1) * gruppe_a.std()**2 + (n_b - 1) * gruppe_b.std()**2) / (n_a + n_b - 2))
cohens_d = (gruppe_a.mean() - gruppe_b.mean()) / pooled_std
print(f"Cohen's d = {cohens_d:.3f}")

Der t-Test ist eines der meistgenutzten Verfahren in Abschlussarbeiten. Eine vollständige Schritt-für-Schritt-Anleitung dazu, wie man einen t-Test in Python durchführt, erklärt auch die Interpretation aller Ausgabewerte.

Chi-Quadrat-Test für kategoriale Variablen

# Kontingenztabelle erstellen
kreuztab = pd.crosstab(df["gruppe"], df["merkmal"])
print(kreuztab)

# Chi-Quadrat-Test
chi2, p, df_chi, erwartet = stats.chi2_contingency(kreuztab)
print(f"χ² = {chi2:.3f}, df = {df_chi}, p = {p:.3f}")

# Effektstärke Cramér's V
n = kreuztab.sum().sum()
cramers_v = np.sqrt(chi2 / (n * (min(kreuztab.shape) - 1)))
print(f"Cramér's V = {cramers_v:.3f}")

Korrelationsanalyse

# Pearson-Korrelation (bei metrischen, normalverteilten Variablen)
r, p_r = stats.pearsonr(df["alter"], df["testergebnis"])
print(f"r = {r:.3f}, p = {p_r:.3f}")

# Spearman-Korrelation (bei ordinalen oder nicht-normalverteilten Daten)
rho, p_rho = stats.spearmanr(df["alter"], df["testergebnis"])
print(f"ρ = {rho:.3f}, p = {p_rho:.3f}")

Wichtig: Berichten Sie in Ihrer Abschlussarbeit immer sowohl den p-Wert als auch die Effektstärke. Ein statistisch signifikantes Ergebnis ohne Effektstärkenangabe ist methodisch unvollständig.

Regressionsanalysen mit statsmodels

Für Regressionsanalysen ist statsmodels die erste Wahl in Python. Das Paket liefert pro Schätzer nicht nur Koeffizienten, sondern auch Standardfehler, t-Werte, p-Werte, Konfidenzintervalle, R², adjustiertes R², F-Test, AIC und BIC – also genau die Ausgaben, die für eine wissenschaftliche Berichterstattung in Abschlussarbeiten notwendig sind.

import statsmodels.formula.api as smf

# OLS-Regression mit R-ähnlicher Formelschreibweise
modell = smf.ols("testergebnis ~ alter + C(gruppe) + motivation", data=df).fit()
print(modell.summary())

# Konfidenzintervalle separat ausgeben
print(modell.conf_int(alpha=0.05))

# Vorhersagewerte und Residuen
df["vorhersage"] = modell.fittedvalues
df["residuum"] = modell.resid

Die Formelschreibweise ("testergebnis ~ alter + C(gruppe)") lehnt sich an R an und erlaubt es, Variablen direkt aus dem pandas-DataFrame einzubinden – ohne zusätzliche Umwandlungsschritte. C(gruppe) kennzeichnet dabei eine kategoriale Variable, für die automatisch Dummy-Kodierung angewendet wird.

Wer eine vollständige Anleitung zur Regressionsanalyse in Python sucht – inklusive Voraussetzungsprüfung, Interpretation und Berichtsformat – findet diese in einem eigenen Beitrag.

ANOVA in Python

Für den Vergleich von mehr als zwei Gruppen eignet sich die ANOVA. Auch hier bietet statsmodels die methodisch sauberste Lösung:

from statsmodels.formula.api import ols
from statsmodels.stats.anova import anova_lm

modell_anova = ols("testergebnis ~ C(gruppe)", data=df).fit()
anova_tabelle = anova_lm(modell_anova, typ=2)
print(anova_tabelle)

Weitere Details zur Durchführung einer ANOVA in Python – einschließlich Post-hoc-Tests und Effektstärken – sind gesondert dokumentiert.

Ergebnisse visualisieren

Abbildungen sind in einer Abschlussarbeit kein Beiwerk – sie sind ein eigenständiges Kommunikationsmittel. Python bietet mit matplotlib und seaborn zwei leistungsfähige Bibliotheken, die sich gut kombinieren lassen.

import matplotlib.pyplot as plt
import seaborn as sns

# Abbildungseinstellungen für Publikationsqualität
plt.rcParams["figure.dpi"] = 300
plt.rcParams["font.size"] = 11

# Boxplot: Testergebnis nach Gruppe
fig, ax = plt.subplots(figsize=(7, 4))
sns.boxplot(data=df, x="gruppe", y="testergebnis", palette="muted", ax=ax)
ax.set_xlabel("Gruppe")
ax.set_ylabel("Testergebnis")
ax.set_title("Testergebnis nach Versuchsgruppe")
plt.tight_layout()
plt.savefig("abb_boxplot_gruppe.png", dpi=300, bbox_inches="tight")
plt.show()

Wichtig: Exportieren Sie Abbildungen stets als PNG oder PDF mit mindestens 300 DPI – viele Hochschulen setzen das für druckfertige Abschlussarbeiten voraus. Eine ausführliche Anleitung zur Erstellung von Diagrammen und Visualisierungen in Python zeigt auch, wie Sie Grafiken für verschiedene Ausgabeformate optimieren.

Ergebnisse dokumentieren und exportieren

Analyseergebnisse müssen aus Python in ein Format gebracht werden, das in die Abschlussarbeit eingebunden werden kann. Das betrifft Tabellen ebenso wie Abbildungen.

Tabellen exportieren

# Deskriptive Tabelle als Excel-Datei speichern
deskriptiv = df[["alter", "testergebnis", "motivation"]].describe().round(2)
deskriptiv.to_excel("tabelle_deskriptiv.xlsx")

# Regressionsergebnisse als CSV
koeffizienten = modell.summary2().tables[1]
koeffizienten.to_csv("tabelle_regression.csv")

Wie Sie Python-Ergebnisse für eine Abschlussarbeit exportieren – inklusive APA-konformer Tabellenformatierung und der Einbindung in Word oder LaTeX – erklärt ein eigener Beitrag.

Reproduzierbarkeit sicherstellen

Dokumentieren Sie in Ihrem Skript immer die verwendeten Paketversionen. Das ist besonders dann wichtig, wenn Ihre Analyse später überprüft oder repliziert werden soll:

import scipy
import statsmodels
import pandas as pd

print(f"pandas: {pd.__version__}")
print(f"scipy: {scipy.__version__}")
print(f"statsmodels: {statsmodels.__version__}")

Typische Fehler und wie Sie sie vermeiden

Auch erfahrene Python-Nutzende machen in Abschlussarbeiten immer wieder dieselben Fehler. Die häufigsten:

• Voraussetzungen nicht prüfen: Jeder Test setzt bestimmte Bedingungen voraus – Normalverteilung, Varianzhomogenität, Skalenniveau. Führen Sie diese Prüfungen explizit durch und berichten Sie sie im Methodenteil.
• Fehlende Werte ignorieren: Python-Funktionen verhalten sich bei NaN-Werten unterschiedlich – manche ignorieren sie automatisch, andere nicht. Prüfen Sie das für jede Funktion explizit.
• Nur p-Werte berichten: Ein p-Wert ohne Effektstärke ist methodisch unvollständig. Berichten Sie immer Cohens d, η², r oder einen anderen geeigneten Effektstärkenkennwert.
• Pakete nicht dokumentieren: Geben Sie im Methodenteil an, welche Python-Version und welche Pakete in welcher Version verwendet wurden.
• Kein Unterschied zwischen scipy und statsmodels: Wer sich unsicher ist, welches Paket wann einzusetzen ist, findet im Beitrag zum Unterschied zwischen statsmodels und scipy eine klare Orientierung.

Wenn Sie unsicher sind, ob Ihre gewählten Methoden zur Forschungsfrage passen, oder wenn Sie bei der Interpretation der Ergebnisse Unterstützung benötigen, bietet die methodische Begleitung für statistische Auswertungen mit Python von QuantExpert eine fachkundige Unterstützung – von der Methodenwahl über die Auswertung bis zur abschlussarbeitstauglichen Darstellung der Ergebnisse.

Python ist ein leistungsfähiges Werkzeug für empirische Abschlussarbeiten – vorausgesetzt, es wird methodisch sauber eingesetzt. Mit der richtigen Paketkombination, einem strukturierten Workflow und einer vollständigen Dokumentation liefert es Ergebnisse, die jedem akademischen Anspruch standhalten.