Python-Tutorial: Explorative Datenanalyse

Wie du inzwischen weißt, nutzt du die Python-Bibliothek pandas zur Datenmanipulation. Wer gerade erst anfängt, könnte denken, das Paket sei nur beim Preprocessing hilfreich. Weit gefehlt: pandas ist auch großartig, um Daten zu erkunden und sie nach dem Preprocessing zu speichern.

Wenn du bereits DataCamps Python-Tutorials gefolgt bist oder in die Grundlagen von SciPy, NumPy, Matplotlib und pandas eingeführt wurdest, ist es zudem eine gute Idee, dein Wissen kurz aufzufrischen.

Dieses Tutorial zeigt dir praktische Wege, deine Daten mit den genannten Paketen effizient zu erkunden, damit du anschließend mit dem Modellieren beginnen kannst:

Du lernst zuerst, wie du Daten importierst — der erste Schritt, den du erfolgreich abschließen musst, bevor du mit deiner Analyse starten kannst.
Falls du nicht genau weißt, was Explorative Datenanalyse (EDA) ist und wie sie sich von Data Mining unterscheidet, klärt dich dieser Abschnitt vorab auf.
Anschließend erhältst du eine grundlegende Beschreibung deiner Daten: Du holst dir beschreibende Statistiken, schaust dir die ersten und letzten Zeilen deines DataFrames an, ziehst Stichproben usw. So bekommst du schnell ein erstes Gefühl für deine Daten — oft verstehst du sie dadurch bereits deutlich besser.
Nachdem du erste Informationen gesammelt hast, lohnt sich ein tieferer Blick durch Abfragen oder Indexierung. Damit kannst du einfache Hypothesen zu deinen Daten testen.
Jetzt, da du deine Daten inspiziert hast, wirst du Features entdecken, die für deine Analyse relevant sind. Du siehst, wie Feature Engineering und Feature Selection dein Ergebnis positiv beeinflussen können.
Als Nächstes erkennst du, dass eine erste Erkundung gut ist — aber du brauchst auch ein Bild von den Herausforderungen deiner Daten, etwa fehlende Werte oder Ausreißer, und natürlich, wie du damit umgehst, und
Zum Schluss lernst du, Muster in deinen Daten zu entdecken — entweder über schnelle Visualisierungen mit Matplotlib oder Bokeh oder über Funktionen zur Berechnung von Korrelationen zwischen Attributen.

Du möchtest einen pandas-Kurs machen? Dann schau dir unseren Kurs Data Manipulation with pandas an!

Daten importieren

Um deine Daten zu erkunden, musst du sie zunächst laden. Dank der Bibliothek pandas ist das schnell erledigt: Du importierst das Paket konventionsgemäß als pd und nutzt die Funktion read_csv(). Ihr übergibst du die URL, unter der die Daten liegen, sowie ein header-Argument. Mit diesem Argument stellst du sicher, dass die Daten korrekt eingelesen werden und die erste Zeile nicht als Spaltennamen interpretiert wird.

Alternativ kannst du weitere Argumente setzen, um den Import korrekt zu steuern: den Trenner über sep bzw. delimiter, eigene Spaltennamen via names oder die Spalte, die als Index des resultierenden DataFrames genutzt werden soll, mit index_col.

Das sind bei Weitem nicht alle Argumente, die read_csv() akzeptiert. Mehr dazu findest du in der Dokumentation.

# Import the `pandas` library as `pd`
import pandas as pd

# Load in the data with `read_csv()`
digits = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/optdigits/optdigits.tra",
                     header=None)

# Print out `digits`
print(digits)

Hier verwendest du read_csv(), weil die Daten komma-separiert sind. Für andere Formate stehen dir u. a. read_table(), read_excel(), read_fwf() und read_clipboard zur Verfügung — für allgemein getrennte Dateien, Excel-Dateien, Fixed-Width-Formate bzw. Daten aus der Zwischenablage.

Außerdem kannst du mit read_sql() SQL-Abfragen oder Tabellen direkt in einen DataFrame laden. Weitere Input-Funktionen findest du in diesem Abschnitt der pandas-Dokumentation.

Was ist Explorative Datenanalyse (EDA)?

Explorative Datenanalyse (EDA) hilft dir einerseits, Fragen zu beantworten, Business-Annahmen zu testen und Hypothesen für weiterführende Analysen zu generieren. Andererseits bereitest du damit Daten für das Modellieren vor. Beiden Einsatzfeldern ist gemeinsam: Du brauchst ein gutes Verständnis deiner Daten — entweder um Antworten zu finden oder um ein Gefühl für die spätere Modellauswertung zu entwickeln.

Es gibt viele Wege, diese Ziele zu erreichen: eine grundlegende Beschreibung der Daten, Visualisierung, das Erkennen von Mustern, das Identifizieren von Herausforderungen bei der Datennutzung usw.

Häufig triffst du im Kontext EDA auf Data Profiling. Dabei fasst du den Datensatz mit beschreibenden Statistiken zusammen, um ihn besser zu verstehen. Ziel ist, ein solides Verständnis der Daten zu erlangen, um anschließend gezielt Abfragen und Visualisierungen durchzuführen. Data Profiling wird oft genutzt, um Datenqualität einzuschätzen. Abhängig vom Ergebnis entscheidest du, ob du Daten korrigierst, verwirfst oder anders behandelst.

Mehr zu Data Profiling erfährst du in einem folgenden Beitrag.

EDA und Data Mining (DM)

EDA unterscheidet sich vom Data Mining, auch wenn beide eng verwandt sind und viele EDA-Techniken ins Data Mining eingeflossen sind. Die Ziele sind ähnlich: EDA erkundet Daten so, dass interessante Merkmale und Beziehungen sichtbar werden. Typischerweise vergleichst du viele Variablen mit verschiedenen Techniken, um systematische Muster zu finden. Data Mining hingegen extrahiert Muster aus den Daten, um Beziehungen zwischen Variablen aufzudecken, die Geschäftsentscheidungen verbessern können. In beiden Fällen gibt es keine oder nur unvollständige a-priori-Erwartungen über die Zusammenhänge.

Im Allgemeinen ist Data Mining eher anwendungsorientiert, während EDA die grundlegende Natur der zugrunde liegenden Phänomene untersucht. Data Mining akzeptiert daher einen „Black-Box“-Ansatz und nutzt neben EDA-Verfahren auch Methoden wie Neuronale Netze, um valide Vorhersagen zu erzeugen, ohne die genaue Natur der zugrunde liegenden Beziehungen offenzulegen.

Grundlegende Beschreibung der Daten

Wie oben beschrieben, geht es bei EDA darum, deine Daten kennenzulernen. Ein elementarer Schritt: eine grundlegende Beschreibung deiner Daten. Das reicht von einem schnellen Überblick bis hin zu leicht verständlichen Kennzahlen, um ein erstes Gefühl für den Datensatz zu bekommen.

Dieser Abschnitt macht keinen harten Unterschied zwischen den Interpretationen, sondern zeigt dir einfache Wege, schnell verständliche Informationen über deinen DataFrame zu sammeln.

Daten beschreiben

Mit describe() bekommst du diverse zusammenfassende Statistiken (NaN-Werte werden ausgeschlossen). Sieh dir dieses Beispiel mit dem berühmten Iris-Datensatz an. Die Daten sind in dem DataCamp-Light-Block bereits geladen:

iris.describe()

Die Funktion liefert Anzahl, Mittelwert, Standardabweichung, Minimum, Maximum und Quantile. Es gibt natürlich viele Wege in Python, an diese Statistiken zu kommen — auch direkt mit pandas. describe() ist ein schneller Start.

Nimm dir außerdem Zeit, die beschreibenden Statistiken wirklich zu verstehen. Damit beginnst du, die Datenqualität einzuschätzen und zu entscheiden, ob du Daten korrigierst, verwirfst oder anders behandelst. Das ist typischerweise der Data-Profiling-Schritt: Du verstehst Datenelemente und Auffälligkeiten besser und prüfst, wie gut die Daten zur Dokumentation und zu den Business-Anforderungen passen.

Hinweis: Du wirst im Verlauf der EDA immer wieder zu diesem Schritt zurückkehren, da spätere Arbeitsschritte die Datenqualität beeinflussen können.

Erste und letzte Zeilen eines DataFrames

Nachdem du ein Gesamtbild erhalten hast, lohnt sich ein Blick direkt in die Daten. Mit head() und tail() siehst du komfortabel die ersten bzw. letzten Zeilen deines DataFrames.

Untersuche die ersten und letzten fünf Zeilen der handschriftlichen Zifferndaten mit head() und tail() im folgenden DataCamp-Light-Block. Die Daten sind bereits geladen:

# Inspect the first 5 rows of `digits`
first = digits._____(5)

# Inspect the last 5 rows
last = digits.____(5)

Das Ergebnis von head() und tail() sagt dir allein noch wenig, wenn du mit der Datenstruktur nicht vertraut bist.

Es sind schlicht Zeilen und Spalten mit numerischen Werten. Lies dir die Datensatzbeschreibung durch, falls noch nicht geschehen. Dort erfährst du, wie die Daten erhoben wurden, und findest die Anzahl der Attribute und Zeilen — hilfreich, um den korrekten Import zu prüfen.

Außerdem lohnt sich ein zweiter Blick auf die numerischen Werte: Auf den ersten Blick wirken die Integer-Werte plausibel.

Bei anderen Datensätzen, etwa mit Datumsangaben, würden hier direkt Fragen aufkommen: „Wurden Datumswerte korrekt als DateTime eingelesen?“, „Wie prüfe ich das?“ und „Wie ändere ich den Datentyp?“.

Solche Fragen adressierst du typischerweise im Data-Profiling-Schritt — mehr dazu in einem späteren Beitrag.

Stichproben ziehen

Bei großen Datensätzen hilft eine Stichprobe, schnell ein Gefühl für die Daten zu entwickeln. Eine einfache Methode ist die Funktion sample() in pandas:

# Take a sample of 5
digits.sample(5)

Etwas aufwendiger, aber lehrreich: Erzeuge einen zufälligen Index und hole damit zufällige Zeilen aus dem DataFrame. Der folgende Code nutzt random.sample zusammen mit range() und len(). Über ix wählst du die gewünschten Zeilen aus.

Falls dir der Einsatz von ix hier nicht klar ist, hilft dir DataCamps vertiefendes Tutorial weiter — der Link steht oben!

Jetzt üben wir Python in der Praxis. Leg los mit der folgenden Aufgabe:

# import `sample` from `random`
from random import ______

# Create a random index
randomIndex = np.array(sample(range(len(______)), 5))

# Get 5 random rows
digitsSample = digits.ix[___________]

# Print the sample
print(____________)

Ein genauerer Blick auf deine Daten: Queries

Nachdem du einen schnellen Überblick hast, tauchst du tiefer ein und untersuchst die Daten mit Abfragen.

Das geht komfortabel mit query(), um einfache Hypothesen zu testen, etwa: „Ist die Petal-Länge meist größer als die Sepal-Länge?“ oder „Gibt es Fälle, in denen beide gleich sind?“.

# Petal length greater than sepal length?
iris.query('Petal_length > Sepal_length')

# Petal length equals sepal length?
iris.query('Petal_length == Sepal_length')

Du siehst: Die Hypothese trifft hier nicht zu — es wird ein leerer DataFrame zurückgegeben.

Hinweis: Dasselbe erreichst du auch mit iris[iris.Petal_length > iris.Sepal_length].

Herausforderungen deiner Daten

Nachdem du Basisinformationen gesammelt hast, lohnt sich ein Blick auf mögliche Stolpersteine. Wenn du bereits Data Profiling gemacht hast, weißt du, ob Werte fehlen, wo Ausreißer liegen usw.

Hier lernst du einfache Wege, solche Punkte zu erkennen, und wie du mit Unregelmäßigkeiten umgehst. Üblicherweise vertiefst du diese Schritte im Data-Profiling — und es ist normal, nach Korrekturen wieder dorthin zurückzukehren.

Fehlende Werte

Prüfe beim Erkunden deiner Daten, ob es fehlende Werte gibt.

Das ist wichtig, weil fehlende Werte die Aussagekraft verringern und Analysen verzerren können. Fehlen bei bestimmten Features Werte, steigt die Wahrscheinlichkeit, dass Klassifikationen oder Vorhersagen danebenliegen.

Ursachen können fehlerhafte Extraktion/Imports sein oder Probleme im Erhebungsprozess. Systeme können ausfallen, Umfragen bleiben teilweise unbeantwortet. Wichtig ist auch, ob ein Muster im Fehlen steckt — hier hilft Data Profiling, um die Datenqualität besser zu verstehen. Mehr zu Mustern fehlender Werte folgt in einem späteren Beitrag.

Kurz: Ursachen fehlender Daten sind vielfältig und hängen vom Kontext ab — aber auch von dir. Darum hast du den Import oben direkt geprüft!

Um Zeilen mit fehlenden Werten zu identifizieren, nutzt du isnull(). Im Ergebnis steht in jeder Zelle True oder False: True bedeutet „fehlender Wert“, False steht für einen vorhandenen Wert.

# Identifiy missing values
pd.isnull(______)

Hier sind die Daten vollständig: Es gibt keine fehlenden Werte.

Hinweis: Das steht auch in der Datensatzbeschreibung des UCI Machine Learning Repository (s. Link oben).

Das ist jedoch nicht immer so. Gut zu wissen, was du bei fehlenden Werten tun kannst:

Löschen: Entferne ganze Datensätze oder behalte nur die mit vollständig vorhandenen Features. Vorsicht: Löschen kann zu Bias führen. Prüfe, ob die Wahrscheinlichkeit fehlender Werte zwischen Datensätzen variiert. Wenn nicht, ist Löschen eine valide Option.
Imputieren: Ersetze fehlende Werte, z. B. mit Mittelwert, Median oder Modus. Überlege, ob du global (alle fehlenden Werte eines Features) oder konditional (z. B. getrennt nach „male“/„female“) imputierst.
Schätzen per Modell: Nutze Regression, ANOVA, logistische Regression oder andere Verfahren. Das ist die komplexeste Variante.
Ähnlichste Nachbarn: Ersetze per KNN (K-Nearest Neighbors) anhand ähnlicher Datensätze.

Alle Methoden haben Vor- und Nachteile. Berücksichtige Zeit, Kosten, Datenkontext usw., bevor du entscheidest.

Wenn du deinen Ansatz gewählt hast, lies weiter und sieh, wie du ihn praktisch umsetzt.

Fehlende Werte auffüllen

Wenn du imputierst, hast du mehrere Optionen.

Nutze pandas fillna() in Kombination mit NumPy. Angenommen, ein DataFrame enthält Gehaltsangaben aus einer homogenen Zielgruppe und die Antwortwahrscheinlichkeit ist über Personen ähnlich, könntest du den Mittelwert der beantworteten Einträge berechnen und fehlende Werte damit füllen.

# Import NumPyimport numpy as np# Calculate the meanmean = np.mean(df.Salary)# Replace missing values with the meandf. = df.Salary.fillna(mean)Bereitgestellt von

Du musst fillna() keinen festen Wert übergeben. Du kannst Nicht-Null-Werte auch vorwärts oder rückwärts fortschreiben, indem du das Argument method setzt: ffill bzw. bfill.

Labels mit fehlenden Werten entfernen

Um Zeilen oder Spalten mit fehlenden Werten auszuschließen, verwende dropna() von pandas:

# Drop rows with missing valuesdf.dropna(axis=0)# Drop columns with missing values df.dropna(axis=1)Bereitgestellt von

Interpolation

Alternativ kannst du interpolieren: interpolate() führt eine lineare Interpolation an fehlenden Punkten durch und „schätzt“ plausible Werte.

df.interpolate()Bereitgestellt von

Über das Argument method stehen dir auch andere Verfahren wie Polynom- oder kubische Interpolation zur Verfügung (hierfür brauchst du SciPy).

Beachte die Grenzen der Interpolation, insbesondere wenn NaN-Werte zu weit von der letzten gültigen Beobachtung entfernt liegen. In solchen Fällen setze ein limit: Eine positive Zahl gibt an, wie viele Werte nach einem Nicht-NaN aufgefüllt werden. Die Standardrichtung ist vorwärts, lässt sich aber mit limit_direction ändern.

Ausreißer

Neben fehlenden Werten kann es stark abweichende Datenpunkte geben — sogenannte Ausreißer. Finde sie über Verteilungschecks einzelner Variablen (Boxplot) oder über Scatterplots, in denen Punkte außerhalb des erwarteten Bereichs liegen.

Ursachen reichen von Systemfehlern bis zu Eingabe-/Verarbeitungsfehlern. Wichtig ist die Auswirkung: Ausreißer verändern Ergebnisse statistischer Tests (Standardabweichung, Mittelwert, Median) und beeinträchtigen Modellannahmen (Normalität) sowie Modellgüte (z. B. Regression, ANOVA).

Umgehen kannst du Ausreißer durch Löschen, Transformieren oder Imputieren — je nach Kontext. Verstehe die Ursache, bevor du entscheidest:

Handelt es sich um Eingabe-/Verarbeitungsfehler, kannst du löschen.
Transformiere z. B. mit Gewichten oder durch Log-Transformation, um die Varianz zu reduzieren.
Imputiere extreme Werte mit Median, Mittelwert oder Modus — analog zu fehlenden Werten.

Die oben beschriebenen Funktionen helfen dir auch beim Umgang mit Ausreißern.

Features deiner Daten

Hinweis: Diesen Schritt gehst du iterativ mit anderen Data-Science-Aufgaben: Du baust und validierst Modelle, passt daraufhin Features an und wiederholst den Prozess.

Feature Engineering

Mit Feature Engineering erhöhst du die Vorhersagekraft von Lernalgorithmen, indem du aus Rohdaten zusätzliche, hilfreiche Features ableitest.

Feature Engineering erfordert Übung — es ist nicht immer offensichtlich, welche Transformationen helfen. Die folgende Liste liefert Anregungen:

Kategorische Variablen kodieren: Wandle Kategorien in Zahlen um mit factorize() — so etwa:

# Factorize the values 
labels,levels = pd.factorize(iris.Class)

# Save the encoded variables in `iris.Class`
iris.Class = labels

# Print out the first rows
iris.Class.head()

Kontinuierliche Variablen in Bins einteilen: Nutze cut(), um Werte einer Spalte zu gruppieren.

# Define your own bins
mybins = range(0, df.age.max(), 10)

# Cut the data with the help of the bins
df['age_bucket'] = pd.cut(df.age, bins=mybins)

# Count the number of values per bucket
df['age_bucket'].value_counts()

Features skalieren: Zentriere deine Daten um 0. Nutze das Preprocessing-Modul von Scikit-Learn:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler().fit(X)

rescaledX = scaler.transform(X)

Tipp: Schau dir das Preprocessing-Modul von Scikit-Learn genauer an — dort findest du viele hilfreiche Funktionen für neue Features.

Das sind nur einige Optionen. Der Schlüssel ist, neue Ideen zu generieren, Features zu kombinieren und ihre Wirksamkeit mit Scikit-Learn zu testen.

Feature Selection

Bei der Feature Selection wählst du die aussagekräftigsten Originalfeatures aus, um die Dimensionalität zu reduzieren. Das klingt ähnlich wie bei Verfahren wie PCA, unterscheidet sich aber: PCA kombiniert korrelierte Attribute zu neuen, „besseren“ Komponenten. Feature Selection kombiniert nicht, sondern bewertet Qualität und Vorhersagekraft und wählt das beste Set aus.

Um wichtige Features zu finden, kannst du RandomForest nutzen: Das Verfahren erzeugt viele Entscheidungsbäume und lässt Variablen abwechselnd weg, um deren Einfluss zu messen. In Python setzt du das mit Scikit-Learn um:

# Import `RandomForestClassifier`
from sklearn.ensemble import RandomForestClassifier

# Isolate Data, class labels and column values
X = iris.iloc[:,0:4]
Y = iris.iloc[:,-1]
names = iris.columns.values

# Build the model
rfc = RandomForestClassifier()

# Fit the model
rfc.fit(X, Y)

# Print the results
print("Features sorted by their score:")
print(sorted(zip(map(lambda x: round(x, 4), rfc.feature_importances_), names), reverse=True))

Du wirst sehen: Das beste Set enthält hier die Petal-Länge und -Breite.

Hinweis: Die Ergebnisse der Feature Selection kannst du mit Matplotlib visualisieren:

# Import `pyplot` and `numpy`import matplotlib.pyplot as pltimport numpy as np# Isolate feature importances importance = rfc.feature_importances_# Sort the feature importances sorted_importances = np.argsort(importance)# Insert paddingpadding = np.arange(len(names)-1) + 0.5# Plot the dataplt.barh(padding, importance[sorted_importances], align='center')# Customize the plotplt.yticks(padding, names[sorted_importances])plt.xlabel("Relative Importance")plt.title("Variable Importance")# Show the plotplt.show()Bereitgestellt von

Muster in deinen Daten

Ein nächster Schritt ist das Erkennen von Mustern, z. B. Korrelationen zwischen Attributen oder zwischen fehlenden Werten. Visualisierung hilft enorm — gern auch interaktiv mit Bokeh oder Plotly.

Korrelationen mit Matplotlib erkennen

Nach der quantitativen Analyse lohnt sich die visuelle Perspektive.

Für schnelle Visualisierungen eignet sich Matplotlib. Ein Hinderungsgrund kann ironischerweise die Datenstruktur sein: 64 Spalten/Features bedeuten hohe Dimensionalität.

Für 2D- oder 3D-Plots brauchst du zwei bzw. drei Dimensionen. Du reduzierst also die Dimensionalität, z. B. mit Principal Component Analysis (PCA):

# Import `PCA` from `sklearn.decomposition`
from sklearn.decomposition import ___

# Build the model
pca = PCA(n_components=2)

# Reduce the data, output is ndarray
reduced_data = pca.fit_transform(_______)

# Inspect the shape of `reduced_data`
reduced_data.______

# print out the reduced data
print(_______________)

Bei der Inspektion der reduzierten Daten siehst du: Es gibt jetzt nur noch zwei Features/Spalten. Die Zeilenzahl bleibt mit 3823 unverändert. Zeit fürs Plotten.

Die Wahl des passenden Plots ist der halbe Weg — welcher passt hier?

Zur Exploration und zum Aufdecken möglicher Zusammenhänge bietet sich ein Scatterplot an. Er zeigt dir Beziehungen zwischen den beiden durch die Dimensionsreduktion entstandenen Features.

import matplotlib.pyplot as pltplt.scatter(reduced_data[:,0], reduced_data[:,1], c=labels, cmap = 'viridis')plt.show()Bereitgestellt von

Correlation Python

Korrelationen mit Bokeh erkennen

Du kannst auch Bokeh nutzen, um interaktive Plots zu erstellen und Korrelationen zu entdecken. Bokeh ist eine interaktive Visualisierungsbibliothek für moderne Webbrowser — ideal für große oder Streaming-Daten, funktioniert aber auch mit „normalen“ Datensätzen, wie im Beispiel.

Der Code ist knapp: Module importieren, Scatterplot erzeugen, die Ausgabe auf Datei setzen und mit show() anzeigen.

# Import the necessary modulesfrom bokeh.charts import Scatter, output_file, show# Construct the scatter plotp = Scatter(iris, x='Petal_length', y='Petal_width', color="Class", title="Petal Length vs Petal Width",            xlabel="Sepal Length", ylabel="Sepal Width")# Output the file output_file('scatter.html')# Show the scatter plotshow(p)Bereitgestellt von

Das Ergebnis kann sich sehen lassen:

Python data exploration

Hinweis: Das Bild hier ist statisch gespeichert, im Notebook oder Terminal ist der Plot interaktiv. Bokeh kann natürlich viel mehr — schau in die Bokeh-Galerie oder in DataCamps Kurs Interactive Data Visualization with Bokeh.

Korrelationen mit pandas berechnen

Visualisierungen sind ein guter Start. Du kannst Korrelationen aber auch quantitativ untersuchen — mit corr() in pandas. Beachte: NaN-/Null-Werte werden ausgeschlossen.

# Pearson correlation
iris.corr()

# Kendall Tau correlation
iris.corr('kendall')

# Spearman Rank correlation
iris.corr('spearman')

Hinweis: Die letzten beiden Maße erfordern ein Ranking der Daten vor der Berechnung. Das erledigst du mit rank(); im Beispiel wurde iris bereits mittels iris.rank() vorbereitet.

Dazu kommen Annahmen: Die Pearson-Korrelation setzt Normalverteilung der Variablen, Linearität und Normalverteilung der Residuen um die Regressionsgerade voraus. Spearman hingegen setzt ordinale Variablen oder monotone Zusammenhänge voraus, nicht zwingend linear.

Kendall Tau misst die Übereinstimmung zwischen zwei gerankten Variablen. Spearman misst den Grad der Assoziation. Beide sind verwandt, unterscheiden sich aber in der Berechnung: Kendall basiert auf der Differenz von konkordanten und diskordanten Paaren relativ zur Gesamtzahl; Spearman basiert auf der Summe quadrierter Rangdifferenzen, normiert mit n und n-1.

Spearman ist oft größer als Kendall Tau, aber nicht immer — bei großen Abweichungen der Beobachtungen kann Spearman kleiner sein. Diese Sensitivität kann nützlich sein.

Wann welches Maß? Kendall Tau hat eine intuitive Interpretation, ist einfacher zu berechnen, liefert oft bessere Schätzungen des Populationsparameters und präzisere p-Werte bei kleinen Stichproben.

Tipp: Nutze print(), um dir die paarweisen Korrelationswerte gezielt ausgeben zu lassen.

Weiter geht's!

Glückwunsch — du hast unser pandas-Tutorial abgeschlossen! Du beherrschst jetzt grundlegende Techniken, um Daten mit Python zu erkunden.

Wenn du tiefer einsteigen willst, passt unsere pandas-Kursreihe perfekt: Schau dir Data Manipulation with pandas, Reshaping Data with pandas oder Joining Data with pandas an.

Wenn du stattdessen Matplotlib weiter erkunden oder mit dem Modellieren starten willst, empfehlen wir DataCamps Python Data Visualization Tutorial oder unser Machine-Learning-Tutorial, in dem du ein Modell zur automatischen Erkennung handschriftlicher Ziffern baust.

Themen

Python Datenwissenschaft Datenanalyse

Technologien

Themen

Python-Tutorial: Explorative Datenanalyse

Entdecke KI

Themen

Python-Kurse

Einführung in Python

Python für Fortgeschrittene

Ähnlich

Python-Arrays

Python Datenstrukturen Tutorial

Python Switch Case Statement: Ein Leitfaden für Anfänger

Python-Anweisungen IF, ELIF und ELSE

Fibonacci-Folge in Python: Lerne und entdecke Programmiertechniken

Loop-Schleifen in Python-Tutorial

Technologien

Themen

Python-Kurse

Einführung in Python

Python für Fortgeschrittene