Einführung in die Datenanalyse mit Python
Python hat sich als die führende Sprache für Datenanalyse etabliert. Die Kombination aus Pandas und NumPy bietet Ihnen alle Werkzeuge, die Sie für professionelle Datenanalyse benötigen. In diesem umfassenden Tutorial lernen Sie, wie Sie diese mächtigen Bibliotheken für reale Datenprojekte einsetzen.
1. NumPy - Die Basis der Datenanalyse
NumPy (Numerical Python) ist die Grundlage für fast alle wissenschaftlichen Python-Bibliotheken. Es bietet schnelle, mehrdimensionale Arrays und mathematische Funktionen.
Installation und Import:
# Installation (falls noch nicht vorhanden)
# pip install numpy pandas matplotlib
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
print(f"NumPy Version: {np.__version__}")
print(f"Pandas Version: {pd.__version__}")NumPy Arrays erstellen und verwenden:
# Arrays erstellen
zahlen = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(f"1D Array: {zahlen}")
print(f"2D Array:\n{matrix}")
# Array-Eigenschaften
print(f"Shape: {matrix.shape}")
print(f"Datentyp: {matrix.dtype}")
print(f"Anzahl Dimensionen: {matrix.ndim}")
# Nützliche Array-Funktionen
nullen = np.zeros((3, 4))
einsen = np.ones((2, 3))
bereich = np.arange(0, 10, 2) # [0, 2, 4, 6, 8]
zufalls_zahlen = np.random.randn(5)
print(f"Nullen:\n{nullen}")
print(f"Bereich: {bereich}")
print(f"Zufallszahlen: {zufalls_zahlen}")Mathematische Operationen:
# Array-Operationen
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
# Grundrechenarten
addition = a + b
multiplikation = a * b
potenz = a ** 2
print(f"Addition: {addition}")
print(f"Multiplikation: {multiplikation}")
print(f"Quadrat: {potenz}")
# Statistische Funktionen
verkaufszahlen = np.array([120, 150, 180, 95, 200, 175, 160])
print(f"Durchschnitt: {np.mean(verkaufszahlen):.2f}")
print(f"Median: {np.median(verkaufszahlen):.2f}")
print(f"Standardabweichung: {np.std(verkaufszahlen):.2f}")
print(f"Minimum: {np.min(verkaufszahlen)}")
print(f"Maximum: {np.max(verkaufszahlen)}")
print(f"Summe: {np.sum(verkaufszahlen)}")2. Pandas - Datenanalyse leicht gemacht
Pandas baut auf NumPy auf und bietet intuitive Datenstrukturen für die Arbeit mit strukturierten Daten. Die zwei Hauptdatenstrukturen sind Series (eindimensional) und DataFrame (zweidimensional).
DataFrames erstellen:
# DataFrame aus Dictionary erstellen
kurs_daten = {
'Name': ['Anna Schmidt', 'Max Weber', 'Lisa Mueller', 'Tom Fischer', 'Sara Klein'],
'Alter': [28, 34, 26, 31, 29],
'Kurs': ['Python Basics', 'Data Science', 'Python Basics', 'Web Dev', 'Data Science'],
'Note': [1.2, 1.5, 1.0, 2.1, 1.3],
'Abgeschlossen': [True, True, True, False, True]
}
df = pd.DataFrame(kurs_daten)
print("Kursteilnehmer DataFrame:")
print(df)
# DataFrame-Informationen
print(f"\nDataFrame Shape: {df.shape}")
print(f"Spalten: {df.columns.tolist()}")
print(f"Datentypen:\n{df.dtypes}")
print(f"\nStatistische Zusammenfassung:\n{df.describe()}")Daten laden und speichern:
# CSV-Datei erstellen (Simulation)
import io
csv_data = """Name,Alter,Abteilung,Gehalt,Erfahrung_Jahre
Anna Mueller,28,IT,65000,3
Max Schmidt,34,Marketing,58000,8
Lisa Weber,26,IT,62000,2
Tom Fischer,31,Vertrieb,55000,5
Sara Klein,29,IT,68000,4
Peter Wolf,45,Management,85000,15
Maria Berg,33,Marketing,60000,7
"""
# CSV aus String lesen (normalerweise: pd.read_csv('datei.csv'))
df_mitarbeiter = pd.read_csv(io.StringIO(csv_data))
print("Mitarbeiter-Daten:")
print(df_mitarbeiter)
# Daten speichern
# df_mitarbeiter.to_csv('mitarbeiter.csv', index=False)
# df_mitarbeiter.to_excel('mitarbeiter.xlsx', index=False)Datenexploration und -bereinigung:
# Erste 5 und letzte 5 Zeilen anzeigen
print("Erste 3 Zeilen:")
print(df_mitarbeiter.head(3))
print("\nLetzte 3 Zeilen:")
print(df_mitarbeiter.tail(3))
# Einzelne Spalten auswählen
it_gehälter = df_mitarbeiter[df_mitarbeiter['Abteilung'] == 'IT']['Gehalt']
print(f"\nIT-Gehälter:\n{it_gehälter}")
# Mehrere Spalten auswählen
info = df_mitarbeiter[['Name', 'Abteilung', 'Gehalt']]
print(f"\nMitarbeiter-Info:\n{info}")
# Daten filtern
erfahrene_mitarbeiter = df_mitarbeiter[df_mitarbeiter['Erfahrung_Jahre'] > 5]
print(f"\nErfahrene Mitarbeiter (>5 Jahre):\n{erfahrene_mitarbeiter}")
# Neue Spalten erstellen
df_mitarbeiter['Gehalt_pro_Jahr_Erfahrung'] = df_mitarbeiter['Gehalt'] / df_mitarbeiter['Erfahrung_Jahre']
df_mitarbeiter['Senior'] = df_mitarbeiter['Erfahrung_Jahre'] > 7
print(f"\nMit neuen Spalten:\n{df_mitarbeiter[['Name', 'Gehalt_pro_Jahr_Erfahrung', 'Senior']]}")Gruppierung und Aggregation:
# Gruppierung nach Abteilung
abteilungs_stats = df_mitarbeiter.groupby('Abteilung').agg({
'Gehalt': ['mean', 'min', 'max', 'count'],
'Erfahrung_Jahre': 'mean',
'Alter': 'mean'
})
print("Statistiken nach Abteilung:")
print(abteilungs_stats)
# Pivot-Tabelle erstellen
pivot = df_mitarbeiter.pivot_table(
values='Gehalt',
index='Abteilung',
aggfunc=['mean', 'count']
)
print(f"\nPivot-Tabelle:\n{pivot}")
# Korrelationsanalyse
numerische_spalten = df_mitarbeiter.select_dtypes(include=[np.number])
korrelation = numerische_spalten.corr()
print(f"\nKorrelationsmatrix:\n{korrelation}")3. Praktisches Beispiel: Verkaufsdatenanalyse
Lassen Sie uns ein realistisches Beispiel durchgehen: die Analyse von Verkaufsdaten einer Python-Kursplattform.
# Verkaufsdaten simulieren
np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=365, freq='D')
verkaufs_daten = pd.DataFrame({
'Datum': dates,
'Kurs': np.random.choice(['Python Basics', 'Data Science', 'Web Development', 'ML Kurs'], 365),
'Verkäufe': np.random.poisson(3, 365), # Poisson-verteilte Verkäufe
'Umsatz': np.random.normal(500, 150, 365), # Normalverteilter Umsatz
'Region': np.random.choice(['Flandern', 'Wallonien', 'Brüssel'], 365)
})
# Negative Umsätze vermeiden
verkaufs_daten['Umsatz'] = np.abs(verkaufs_daten['Umsatz'])
print("Verkaufsdaten Übersicht:")
print(verkaufs_daten.head())
print(f"\nGesamtstatistiken:\n{verkaufs_daten.describe()}")
# Zeitreihenanalyse
verkaufs_daten['Monat'] = verkaufs_daten['Datum'].dt.month
verkaufs_daten['Quartal'] = verkaufs_daten['Datum'].dt.quarter
verkaufs_daten['Wochentag'] = verkaufs_daten['Datum'].dt.day_name()
# Monatliche Zusammenfassung
monatliche_stats = verkaufs_daten.groupby('Monat').agg({
'Verkäufe': 'sum',
'Umsatz': 'sum'
}).round(2)
print(f"\nMonatliche Verkäufe und Umsätze:\n{monatliche_stats}")
# Top-Performance nach Kurs
kurs_performance = verkaufs_daten.groupby('Kurs').agg({
'Verkäufe': 'sum',
'Umsatz': 'sum'
}).sort_values('Umsatz', ascending=False)
print(f"\nKurs-Performance:\n{kurs_performance}")
# Regionale Analyse
regionale_stats = verkaufs_daten.groupby('Region').agg({
'Verkäufe': ['sum', 'mean'],
'Umsatz': ['sum', 'mean']
}).round(2)
print(f"\nRegionale Statistiken:\n{regionale_stats}")4. Datenvisualisierung mit Matplotlib
Visualisierung ist ein entscheidender Teil der Datenanalyse. Matplotlib, in Kombination mit Pandas, macht es einfach, aussagekräftige Diagramme zu erstellen.
# Grundlegende Visualisierungen
fig, axes = plt.subplots(2, 2, figsize=(15, 10))
# 1. Verkäufe über Zeit
monthly_sales = verkaufs_daten.groupby('Monat')['Verkäufe'].sum()
axes[0, 0].plot(monthly_sales.index, monthly_sales.values, marker='o')
axes[0, 0].set_title('Monatliche Verkäufe')
axes[0, 0].set_xlabel('Monat')
axes[0, 0].set_ylabel('Anzahl Verkäufe')
# 2. Umsatz nach Kurs (Balkendiagramm)
kurs_umsatz = verkaufs_daten.groupby('Kurs')['Umsatz'].sum().sort_values(ascending=False)
axes[0, 1].bar(kurs_umsatz.index, kurs_umsatz.values, color=['skyblue', 'lightgreen', 'coral', 'gold'])
axes[0, 1].set_title('Umsatz nach Kurs')
axes[0, 1].set_ylabel('Umsatz (€)')
axes[0, 1].tick_params(axis='x', rotation=45)
# 3. Verkäufe nach Wochentag (Boxplot)
wochentag_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
verkaufs_daten.boxplot(column='Verkäufe', by='Wochentag', ax=axes[1, 0])
axes[1, 0].set_title('Verkäufe nach Wochentag')
# 4. Korrelation Verkäufe vs Umsatz (Scatter plot)
axes[1, 1].scatter(verkaufs_daten['Verkäufe'], verkaufs_daten['Umsatz'], alpha=0.6)
axes[1, 1].set_title('Verkäufe vs Umsatz')
axes[1, 1].set_xlabel('Anzahl Verkäufe')
axes[1, 1].set_ylabel('Umsatz (€)')
plt.tight_layout()
# plt.show() # Auskommentiert für Demo
print("Diagramme erstellt! (plt.show() zum Anzeigen verwenden)")
# Heatmap für regionale Performance
region_kurs = verkaufs_daten.pivot_table(
values='Umsatz',
index='Region',
columns='Kurs',
aggfunc='sum'
)
print(f"\nRegion-Kurs Umsatz-Matrix:\n{region_kurs}")5. Erweiterte Pandas-Techniken
Für fortgeschrittene Datenanalyse bietet Pandas viele mächtige Funktionen:
# 1. Rolling Window Analysis (Gleitende Durchschnitte)
verkaufs_daten_sorted = verkaufs_daten.sort_values('Datum')
verkaufs_daten_sorted['Verkäufe_7_Tage_Durchschnitt'] = verkaufs_daten_sorted['Verkäufe'].rolling(window=7).mean()
verkaufs_daten_sorted['Verkäufe_30_Tage_Durchschnitt'] = verkaufs_daten_sorted['Verkäufe'].rolling(window=30).mean()
print("Gleitende Durchschnitte:")
print(verkaufs_daten_sorted[['Datum', 'Verkäufe', 'Verkäufe_7_Tage_Durchschnitt']].head(10))
# 2. Quartile und Outlier-Erkennung
Q1 = verkaufs_daten['Umsatz'].quantile(0.25)
Q3 = verkaufs_daten['Umsatz'].quantile(0.75)
IQR = Q3 - Q1
# Outlier definieren
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
outliers = verkaufs_daten[(verkaufs_daten['Umsatz'] < lower_bound) |
(verkaufs_daten['Umsatz'] > upper_bound)]
print(f"\nOutliers im Umsatz ({len(outliers)} von {len(verkaufs_daten)}):")
print(outliers[['Datum', 'Kurs', 'Umsatz']].head())
# 3. String-Operationen
verkaufs_daten['Kurs_Kurz'] = verkaufs_daten['Kurs'].str[:4] # Erste 4 Zeichen
verkaufs_daten['Ist_Python'] = verkaufs_daten['Kurs'].str.contains('Python')
print(f"\nString-Operationen:")
print(verkaufs_daten[['Kurs', 'Kurs_Kurz', 'Ist_Python']].head())
# 4. MultiIndex und erweiterte Gruppierung
multi_group = verkaufs_daten.groupby(['Region', 'Kurs']).agg({
'Verkäufe': ['sum', 'mean'],
'Umsatz': ['sum', 'mean']
}).round(2)
print(f"\nMulti-Level Gruppierung:\n{multi_group.head(10)}")💡 Best Practices für die Datenanalyse:
- Daten verstehen: Schauen Sie sich immer zuerst die Datenstruktur an (.info(), .describe())
- Datenqualität prüfen: Suchen Sie nach fehlenden Werten und Duplikaten
- Visualisieren Sie früh: Erste Plots helfen beim Verständnis der Daten
- Kleine Schritte: Testen Sie Operationen an kleinen Datenmengen
- Dokumentieren Sie: Kommentieren Sie Ihren Code ausführlich
- Performance beachten: Nutzen Sie vectorized operations statt Schleifen
6. Performance-Tipps
# Effiziente Pandas-Operationen
import time
# 1. Vectorized operations vs. Schleifen
large_df = pd.DataFrame({
'werte': np.random.randn(100000)
})
# Langsam: Schleife
start_time = time.time()
result_slow = []
for value in large_df['werte']:
result_slow.append(value * 2)
slow_time = time.time() - start_time
# Schnell: Vectorized operation
start_time = time.time()
result_fast = large_df['werte'] * 2
fast_time = time.time() - start_time
print(f"Schleife: {slow_time:.4f} Sekunden")
print(f"Vectorized: {fast_time:.4f} Sekunden")
print(f"Speedup: {slow_time/fast_time:.1f}x schneller")
# 2. Speicher-effiziente Datentypen
print(f"\nSpeicherverbrauch vorher: {large_df.memory_usage(deep=True).sum()} bytes")
# Optimierte Datentypen verwenden
large_df['kategorie'] = pd.Categorical(np.random.choice(['A', 'B', 'C'], 100000))
large_df['kleine_int'] = np.random.randint(0, 100, 100000).astype('int8')
print(f"Speicherverbrauch nachher: {large_df.memory_usage(deep=True).sum()} bytes")
# 3. Chunk-Processing für große Dateien
def process_large_csv(filename, chunksize=10000):
"""Verarbeitung großer CSV-Dateien in Chunks"""
total_rows = 0
total_sum = 0
for chunk in pd.read_csv(filename, chunksize=chunksize):
# Verarbeitung für jeden Chunk
total_rows += len(chunk)
total_sum += chunk['numeric_column'].sum() # Beispiel
return total_rows, total_sum
print("\nChunk-Processing Beispiel definiert")Fazit und nächste Schritte
Mit Pandas und NumPy haben Sie mächtige Werkzeuge für die Datenanalyse kennengelernt. Diese Bibliotheken bilden das Fundament für fortgeschrittene Data Science-Projekte.
Empfohlene nächste Schritte:
- Erkunden Sie Seaborn für erweiterte Visualisierungen
- Lernen Sie Plotly für interaktive Diagramme
- Vertiefen Sie sich in Zeitreihenanalyse
- Entdecken Sie Scikit-learn für Machine Learning
- Melden Sie sich für unseren Data Science Kurs an