Python
Pandas Crosstab: Ein Anfängerleitfaden zur mühelosen Analyse

Pandas Crosstab: Ein Anfängerleitfaden zur mühelosen Analyse

MoeNagy Dev

Was ist Pandas Crosstab?

Die crosstab()-Funktion in der Pandas-Bibliothek ist ein leistungsstarkes Tool zur Erstellung von Kontingenztabellen, auch als Kreuztabulierungen bekannt. Sie ermöglicht die Analyse der Beziehung zwischen zwei oder mehr kategorischen Variablen, indem sie eine tabellarische Darstellung ihrer Häufigkeitsverteilung liefert.

Die crosstab()-Funktion nimmt eine oder mehrere Serien oder kategoriale Variablen als Eingabe und generiert eine zweidimensionale Tabelle, in der die Zeilen eine Variable repräsentieren und die Spalten eine andere Variable repräsentieren. Die resultierende Tabelle zeigt die Anzahl oder Häufigkeit der Kombinationen der Eingabevariablen.

Die Hauptfunktionen und Anwendungsfälle von crosstab() umfassen:

  • Häufigkeitsanalyse: Identifizieren der Häufigkeit oder Anzahl verschiedener Kombinationen von kategorischen Variablen.
  • Kontingenztafel: Erstellen einer Kontingenztafel zur Analyse der Beziehung zwischen zwei oder mehr kategorischen Variablen.
  • Pivot-Tabelle: Generieren einer ähnlichen Ausgabe wie eine Pivot-Tabelle, die weiter angepasst und analysiert werden kann.
  • Bedingte Wahrscheinlichkeiten: Berechnung der bedingten Wahrscheinlichkeiten zwischen den Variablen.
  • Datenexploration: Untersuchung der Verteilung und Beziehungen in Ihrem Datensatz.

Erstellen einer einfachen Crosstab-Tabelle

Beginnen wir damit, einen Beispieldatensatz zu erstellen, mit dem wir arbeiten können:

import pandas as pd
 
# Generiere einen Beispieldatensatz
data = {
    'Geschlecht': ['Männlich', 'Weiblich', 'Männlich', 'Weiblich', 'Männlich', 'Weiblich'],
    'Alter': ['Jung', 'Jung', 'Alt', 'Alt', 'Jung', 'Alt'],
    'Anzahl': [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)

Nun können wir die crosstab()-Funktion verwenden, um eine einfache Crosstab-Tabelle zu erstellen:

pd.crosstab(df['Geschlecht'], df['Alter'])

Dies liefert eine Tabelle, die die Anzahl jeder Kombination von 'Geschlecht' und 'Alter' im Datensatz zeigt.

Alter   Alt  Jung
Geschlecht          
Weiblich    12      8
Männlich     6    15

Die Zeilen repräsentieren die 'Geschlecht'-Variable und die Spalten repräsentieren die 'Alter'-Variable. Die Werte in der Tabelle zeigen die Anzahl jeder Kombination.

Anpassen der Crosstab-Tabelle

Sie können die crosstab()-Funktion weiter anpassen, um Ihren Bedürfnissen gerecht zu werden. Lassen Sie uns einige der verfügbaren Optionen erkunden.

Festlegen von Zeilen- und Spaltenbezeichnungen

Sie können benutzerdefinierte Bezeichnungen für die Zeilen und Spalten mithilfe der Parameter index und columns festlegen:

pd.crosstab(df['Geschlecht'], df['Alter'], rownames=['Geschlecht'], colnames=['Alter'])

Dies erzeugt die gleiche Ausgabe wie zuvor, jedoch mit benutzerdefinierten Zeilen- und Spaltenbezeichnungen.

Anwendung von Aggregatfunktionen

Standardmäßig zählt crosstab() die Anzahl der Vorkommnisse für jede Kombination von Variablen. Sie können dieses Verhalten ändern, indem Sie eine Aggregatfunktion mit dem Parameter aggfunc anwenden:

pd.crosstab(df['Geschlecht'], df['Alter'], values=df['Anzahl'], aggfunc=sum)

Dies erstellt eine Crosstab-Tabelle, die die 'Anzahl'-Werte für jede Kombination von 'Geschlecht' und 'Alter' summiert.

Umgang mit fehlenden Werten

Wenn Ihre Daten fehlende Werte enthalten, können Sie steuern, wie diese behandelt werden, indem Sie die Parameter margins und margins_name verwenden:

pd.crosstab(df['Geschlecht'], df['Alter'], margins=True, margins_name='Gesamt')

Dies fügt der Crosstab-Tabelle eine 'Gesamt'-Zeile und -Spalte hinzu, die die Gesamtanzahl für jede Zeile und Spalte einschließlich des Gesamtüberblicks angibt.

Fortgeschrittene Crosstab-Techniken

Arbeiten mit mehrstufigen Indizes

Die crosstab()-Funktion kann auch mehrstufige Indizes in Ihren Daten verarbeiten. Erstellen wir einen Beispieldatensatz mit einem mehrstufigen Index:

data = {
    ('Geschlecht', ''): ['Männlich', 'Weiblich', 'Männlich', 'Weiblich', 'Männlich', 'Weiblich'],
    ('Alter', ''): ['Jung', 'Jung', 'Alt', 'Alt', 'Jung', 'Alt'],
    ('Anzahl', ''): [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)
df.columns = pd.MultiIndex.from_tuples(df.columns)

Nun können wir eine Crosstab-Tabelle mit dem mehrstufigen Index erstellen:

pd.crosstab(df[('Geschlecht', '')], df[('Alter', '')])

Die Ausgabe wird einen mehrstufigen Index für sowohl die Zeilen als auch die Spalten haben, der die Struktur der Eingabedaten widerspiegelt.

Normalisierung der Crosstab-Tabelle

Sie können die Crosstab-Tabelle normalisieren, um anstelle der Rohdaten die relativen Häufigkeiten anzuzeigen. Dies kann mit dem Parameter normalize durchgeführt werden:

pd.crosstab(df['Geschlecht'], df['Alter'], normalize='index')

Dies normalisiert die Crosstab-Tabelle, indem jeder Wert durch die Summe der Zeile geteilt wird, was zu prozentualen Werten pro Zeile führt.

Visualisierung der Crosstab-Daten

Um die Crosstab-Daten zu visualisieren, können Sie verschiedene Plotting-Funktionen nutzen, die von Pandas oder anderen Visualisierungsbibliotheken wie Matplotlib oder Seaborn bereitgestellt werden. Zum Beispiel:

import matplotlib.pyplot as plt
 
crosstab = pd.crosstab(df['Geschlecht'], df['Alter'])
crosstab.plot(kind='bar', figsize=(8, 6))
plt.title('Crosstab von Geschlecht und Alter')
plt.xlabel('Geschlecht')
plt.ylabel('Anzahl')
plt.show()

Dies erstellt ein Balkendiagramm der Crosstab-Daten, das hilfreich sein kann, um die Beziehungen zwischen den Variablen zu verstehen.

Filtern und Sortieren der Crosstab-Tabelle

Filtern der Crosstab-Tabelle basierend auf Kriterien

Sie können die Crosstab-Tabelle basierend auf bestimmten Kriterien filtern, indem Sie die Standard-Indexierungs- und Booleschen Maskierungstechniken von Pandas verwenden:

crosstab = pd.crosstab(df['Geschlecht'], df['Alter'])
gefilterte_crosstab = crosstab.loc[crosstab['Jung'] > 5]

Dies erstellt eine neue Crosstab-Tabelle, die nur die Zeilen enthält, bei denen der Wert in der Spalte 'Jung' größer als 5 ist.

Sortieren der Crosstab-Zeilen und -Spalten

Um die Zeilen und Spalten der Crosstab-Tabelle zu sortieren, können Sie die Methode sort_index() verwenden:

crosstab = pd.crosstab(df['Geschlecht'], df['Alter'])
sortierte_kreuztabelle = kreuztabelle.sort_index(axis=0, ascending=False)

Dies sortiert die Zeilen der Kreuztabelle in absteigender Reihenfolge.

Kombination von Filterung und Sortierung

Sie können Filterung und Sortierung kombinieren, um die Ausgabe der Kreuztabelle weiter anzupassen:

kreuztabelle = pd.crosstab(df['Geschlecht'], df['Alter'])
gefilterte_sortierte_kreuztabelle = kreuztabelle.loc[kreuztabelle['Jung'] > 5].sort_index(axis=0, ascending=False)

Dies filtert zuerst die Kreuztabelle, um nur Zeilen einzuschließen, bei denen der Wert der Spalte 'Jung' größer als 5 ist, und sortiert dann die Zeilen in absteigender Reihenfolge.

Kreuztabellen mit kategorialen Daten

Arbeit mit kategorialen Variablen

Beim Arbeiten mit kategorialen Variablen ist es wichtig sicherzustellen, dass sie richtig als kategorische Datentypen codiert sind. Sie können die astype() Methode verwenden, um eine Spalte in einen kategorischen Datentyp umzuwandeln:

df['Geschlecht'] = df['Geschlecht'].astype('category')
df['Alter'] = df['Alter'].astype('category')

Anzeigen einer Kreuztabelle für kategoriale Merkmale

Sobald Ihre kategorialen Variablen eingerichtet sind, können Sie eine Kreuztabelle erstellen, um die Beziehungen zwischen ihnen zu analysieren:

pd.crosstab(df['Geschlecht'], df['Alter'])

Dies zeigt die Kreuztabelle für die kategorialen Variablen 'Geschlecht' und 'Alter' an.

Umgang mit NaN-Werten in kategorialen Daten

Wenn Ihre Daten NaN (fehlende) Werte in den kategorialen Variablen enthalten, können Sie diese mit dem dropna -Parameter behandeln:

pd.crosstab(df['Geschlecht'], df['Alter'], dropna=False)

Dies schließt die NaN-Werte in der Kreuztabelle ein, sodass Sie auch die fehlenden Daten analysieren können.

Kreuztabellen mit zeitbezogenen Daten

Generieren von Kreuztabellen für zeitbasierte Daten

Wenn Ihre Daten zeitbezogene Informationen enthalten, können Sie die crosstab() Funktion verwenden, um die Beziehungen im Laufe der Zeit zu analysieren. Erstellen Sie zunächst ein Beispiel-DataFrame mit einer Datums-Spalte:

data = {
    'Datum': ['2022-01-01', '2022-01-02', '2022-01-03', '2022-01-04', '2022-01-05', '2022-01-06'],
    'Geschlecht': ['Männlich', 'Weiblich', 'Männlich', 'Weiblich', 'Männlich', 'Weiblich'],
    'Alter': ['Jung', 'Jung', 'Alt', 'Alt', 'Jung', 'Alt'],
    'Anzahl': [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)
df['Datum'] = pd.to_datetime(df['Datum'])

Nun können Sie eine Kreuztabelle mit der 'Datum'-Spalte als einer der Variablen erstellen:

pd.crosstab(df['Datum'].dt.date, df['Geschlecht'])

Dies erzeugt eine Kreuztabelle, die die Anzahl jedes Geschlechts für jedes Datum im DataFrame anzeigt.

Analyse von Trends und Mustern im Laufe der Zeit

Sie können die Trends und Muster in der zeitbasierten Kreuztabelle weiter analysieren, indem Sie zusätzliche pandas Funktionen oder Visualisierungen verwenden:

kreuztabelle = pd.crosstab(df['Datum'].dt.date, df['Geschlecht'])
kreuztabelle.plot(kind='line', figsize=(10, 6))
plt.title('Geschlechtszählungen im Laufe der Zeit')
plt.xlabel('Datum')
plt.ylabel('Anzahl')
plt.show()

Dies erstellt ein Liniendiagramm der Geschlechtszählungen im Laufe der Zeit und ermöglicht es Ihnen, Trends oder Muster in den Daten zu identifizieren.

Bearbeitung von datums- und zeitbezogenen Operationen

Bei der Arbeit mit zeitbezogenen Daten müssen möglicherweise verschiedene datums- und zeitbezogene Operationen durchgeführt werden, z. B. Gruppierung nach Jahr, Monat oder Tag. Sie können den dt-Accessor auf der 'Datum'-Spalte verwenden, um auf diese Operationen zuzugreifen:

pd.crosstab(df['Datum'].dt.month, df['Geschlecht'])

Dies erstellt eine Kreuztabelle, die die Anzahl jedes Geschlechts für jeden Monat in den Daten anzeigt.

Kombinieren von Kreuztabelle mit anderen pandas Funktionen

Integrieren von Kreuztabelle mit groupby()

Sie können die Funktion crosstab() mit der Funktion groupby() kombinieren, um komplexere Analysen durchzuführen. Sie können beispielsweise zuerst die Daten nach einer Variable gruppieren und dann eine Kreuztabelle auf den gruppierten Daten erstellen:

gruppiert_df = df.groupby(['Geschlecht', 'Alter'])
pd.crosstab(gruppiert_df.groups.keys(), df['Datum'].dt.date)

Dies erstellt eine Kreuztabelle, die die Anzahl jeder Kombination von 'Geschlecht' und 'Alter' für jedes Datum in den Daten anzeigt.

Kombinieren von Kreuztabelle mit pivot_table()

Die Funktion crosstab() kann auch in Verbindung mit der Funktion pivot_table() verwendet werden, um fortgeschrittene Datenanalysen durchzuführen:

pivot_tabelle = pd.pivot_table(df, index=['Geschlecht', 'Alter'], columns='Datum', values='Anzahl', aggfunc='sum')

Dies erstellt eine Pivot-Tabelle, die die Summe von 'Anzahl' für jede Kombination von 'Geschlecht' und 'Alter' über verschiedene Daten anzeigt.

Erkundung anderer pandas Funktionen für Kreuztabelle

Obwohl crosstab() ein leistungsstarkes Werkzeug ist, gibt es andere pandas Funktionen, die in Kombination mit oder als Alternativen zu crosstab() verwendet werden können. Einige Beispiele sind:

  • value_counts(): Erhalten Sie die Häufigkeiten der eindeutigen Werte in einer Series.
  • pivot(): Erstellen Sie eine Pivot-Tabelle im Tabellenkalkulationsstil als DataFrame.
  • melt(): Nicht kopfzeilige Umwandlung eines DataFrame in Langformat.
  • cut() und qcut(): Binieren Sie kontinuierliche Daten in Intervalle.

Die Erkundung dieser Funktionen kann Ihnen helfen, Ihr Datenanalyse-Toolkit zu erweitern und den für Ihren spezifischen Anwendungsfall geeignetsten Ansatz zu finden.

Funktionen

Funktionen sind ein grundlegendes Konzept in Python, mit dem Sie eine Reihe von Anweisungen kapseln und in Ihrem Code wiederverwenden können. Funktionen können Eingabeparameter enthalten, Operationen ausführen und ein Ergebnis zurückgeben.

Hier ist ein Beispiel für eine einfache Funktion, die die Fläche eines Rechtecks berechnet:

def berechne_fläche(länge, breite):
    fläche = länge * breite
    return fläche
 
# Funktion aufrufen und das Ergebnis ausgeben
ergebnis = berechne_fläche(5, 10)
print(f"Die Fläche des Rechtecks beträgt {ergebnis} Flächeneinheiten.")

In diesem Beispiel nimmt die Funktion berechne_fläche() zwei Parameter, länge und breite, entgegen und gibt die berechnete Fläche zurück. Sie können die Funktion aufrufen und das Ergebnis in der Variable ergebnis speichern, das dann in die Konsole gedruckt wird.

Funktionen können auch Standardparameterwerte haben, wodurch Sie die Funktion aufrufen können, ohne alle Argumente bereitzustellen:

def grüße(name, nachricht="Hallo"):
    print(f"{nachricht}, {name}!")
 
grüße("Alice")  # Ausgabe: Hallo, Alice!

Greifen Sie auf die Funktion greet() zu, indem Sie den name- und message-Parameter übergeben. Der Standardwert für den message-Parameter ist "Hello", sodass Sie die Funktion nur mit dem name-Argument aufrufen können und sie die Standardnachricht verwendet.

Module und Pakete

Mit dem modularen Design von Python können Sie Ihren Code in wiederverwendbare Komponenten namens Module organisieren. Module sind Python-Dateien, die Funktionen, Klassen und Variablen enthalten, die importiert und in anderen Teilen Ihres Codes verwendet werden können.

Hier ist ein Beispiel für das Erstellen eines einfachen Moduls namens math_utils.py:

def add(a, b):
    return a + b
 
def subtract(a, b):
    return a - b
 
def multiply(a, b):
    return a * b
 
def divide(a, b):
    return a / b

Sie können dann die Funktionen aus diesem Modul in einer anderen Python-Datei importieren und verwenden:

import math_utils
 
result = math_utils.add(5, 3)
print(result)  # Ausgabe: 8
 
result = math_utils.subtract(10, 4)
print(result)  # Ausgabe: 6

Module können auch in Paketen organisiert werden, die Verzeichnisse sind, die mehrere Module enthalten. Dadurch können Sie eine hierarchische Struktur für Ihren Code erstellen und ihn leichter verwalten.

Hier ist ein Beispiel für eine Paketstruktur:

my_package/
    __init__.py
    math/
        __init__.py
        operations.py
        geometry.py
    data/
        __init__.py
        file_utils.py
        database_utils.py

In diesem Beispiel enthält das Paket my_package zwei Unterpakete: math und data. Jedes Unterpaket hat seinen eigenen Satz von Modulen, und die __init__.py-Dateien ermöglichen es Python, diese Verzeichnisse als Pakete zu erkennen.

Sie können dann die Funktionen aus den Modulen innerhalb des Pakets importieren und verwenden:

from my_package.math.operations import add, subtract
from my_package.data.file_utils import read_file
 
result = add(5, 3)
print(result)  # Ausgabe: 8
 
data = read_file("data.txt")
print(data)

Objektorientierte Programmierung (OOP)

Die objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das sich auf die Erstellung von Objekten konzentriert, die Instanzen von Klassen sind. Klassen definieren die Struktur und das Verhalten von Objekten, und Objekte können miteinander interagieren, um komplexe Probleme zu lösen.

Hier ist ein Beispiel für eine einfache Klasse, die eine Person repräsentiert:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def greet(self):
        print(f"Hallo, mein Name ist {self.name} und ich bin {self.age} Jahre alt.")
 
# Erstellen Sie ein Person-Objekt und rufen Sie die greet-Methode auf
person = Person("Alice", 30)
person.greet()  # Ausgabe: Hallo, mein Name ist Alice und ich bin 30 Jahre alt.

In diesem Beispiel hat die Klasse Person zwei Attribute (name und age) und eine Methode (greet()). Wenn Sie ein neues Person-Objekt erstellen, können Sie die Anfangswerte für die Attribute mithilfe der __init__()-Methode festlegen, die eine spezielle Methode ist, die Konstruktor genannt wird.

Sie können auch Unterklassen erstellen, die von einer Basisklasse erben und die Funktionalität der Basisklasse erweitern:

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade
 
    def study(self):
        print(f"{self.name} lernt für ihre {self.grade}. Klasse.")
 
# Erstellen Sie ein Student-Objekt und rufen Sie seine Methoden auf
student = Student("Bob", 15, "10.")
student.greet()  # Ausgabe: Hallo, mein Name ist Bob und ich bin 15 Jahre alt.
student.study()  # Ausgabe: Bob lernt für ihre 10. Klasse.

In diesem Beispiel erbt die Klasse Student von der Klasse Person und fügt ein grade-Attribut und eine study()-Methode hinzu. Die __init__()-Methode der Klasse Student ruft die __init__()-Methode der Klasse Person mit der super()-Funktion auf, um die name- und age-Attribute zu initialisieren.

Ausnahmen und Fehlerbehandlung

Die Ausnahmeverarbeitung von Python ermöglicht es Ihnen, unerwartete Situationen in Ihrem Code zu behandeln und eine elegante Möglichkeit zum Umgang mit Fehlern bereitzustellen. Ausnahmen werden ausgelöst, wenn während der Ausführung eines Programms ein Fehler auftritt, und Sie können Code schreiben, um diese Ausnahmen abzufangen und zu behandeln.

Hier ist ein Beispiel, wie man eine ZeroDivisionError-Ausnahme behandelt:

def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Fehler: Division durch Null ist nicht erlaubt.")
        return None
 
print(divide(10, 2))  # Ausgabe: 5.0
print(divide(10, 0))  # Ausgabe: Fehler: Division durch Null ist nicht erlaubt.

In diesem Beispiel verwendet die Funktion divide() einen try-except-Block, um die ZeroDivisionError-Ausnahme abzufangen. Wenn die Division die Ausnahme auslöst, wird der Code im except-Block ausgeführt und eine Meldung wird auf der Konsole ausgegeben. Wenn die Division erfolgreich ist, wird das Ergebnis zurückgegeben.

Sie können auch eigene benutzerdefinierte Ausnahmen definieren, indem Sie eine neue Klasse erstellen, die von der integrierten Exception-Klasse erbt:

class NegativeNumberError(Exception):
    pass
 
def square_root(number):
    if number < 0:
        raise NegativeNumberError("Fehler: Die Quadratwurzel einer negativen Zahl kann nicht berechnet werden.")
    return number ** 0.5
 
try:
    print(square_root(16))  # Ausgabe: 4.0
    print(square_root(-4))
except NegativeNumberError as e:
    print(e)  # Ausgabe: Fehler: Die Quadratwurzel einer negativen Zahl kann nicht berechnet werden.

In diesem Beispiel löst die Funktion square_root() eine benutzerdefinierte NegativeNumberError-Ausnahme aus, wenn die Eingabenummer negativ ist. Der try-except-Block fängt die Ausnahme ab und gibt die Fehlermeldung aus.

Fazit

In diesem Python-Tutorial haben Sie verschiedene fortgeschrittene Konzepte in Python gelernt, darunter Funktionen, Module und Pakete, objektorientierte Programmierung und Fehlerbehandlung. Diese Themen sind entscheidend für den Aufbau komplexerer und robusterer Python-Anwendungen. Denke daran, der beste Weg, um deine Python-Fähigkeiten zu verbessern, ist das Üben des Schreibens von Code und das Lösen von Problemen. Experimentiere mit den Beispielen in diesem Tutorial und versuche, diese Konzepte auf deine eigenen Projekte anzuwenden. Erkunde außerdem weiterhin das umfangreiche Ökosystem von Python-Bibliotheken und Frameworks, die die Möglichkeiten deiner Python-Programme erheblich erweitern können.

Viel Spaß beim Codieren!

MoeNagy Dev