Datenanalyse mit Python – Data Analytics Python Guide

Hallo Python-Enthusiasten! Ob ihr euch für ein Job-Interview vorbereitet, an einem Projekt arbeitet oder einfach nur die unendlichen Möglichkeiten der Datenanalyse mit Python entdecken wollt – dieser Beitrag wird euch sicherlich helfen.

Warum Python für Datenanalyse?

Python ist eine vielseitige Sprache, die sich durch ihre einfache Syntax und ihre mächtigen Pakete für Datenanalyse und -verarbeitung auszeichnet. Unternehmen weltweit setzen auf Python, um wertvolle Erkenntnisse aus ihren Daten zu gewinnen und datengetriebene Entscheidungen zu treffen.

Weitere Python Challenges findest du hier:

Typische Interviewfragen: Was dich erwartet

Hier sind 20 typische Interviewfragen für Data Analytics Experten, die sich auf Python spezialisiert haben:

Interviewfragen

  1. Was ist der Unterschied zwischen einer Liste und einem Tuple in Python?
  2. Wie würdest du in Pandas fehlende Werte in einem DataFrame behandeln?
  3. Was sind die Hauptunterschiede zwischen matplotlib und seaborn?
  4. Wie unterscheiden sich iloc und loc in Pandas?
  5. Wie würdest du in Python eine Verbindung zu einer SQL-Datenbank herstellen?
  6. Was versteht man unter „Overfitting“ in Machine Learning?
  7. Erkläre den Unterschied zwischen einer Serie und einem DataFrame in Pandas.
  8. Was macht die groupby-Methode in Pandas?
  9. Wie würdest du in Python einen Zeitstempel in ein Datumsformat umwandeln?
  10. Was ist Lambda in Python und wie würdest du es verwenden?
  11. Welche Metrik würdest du verwenden, um die Genauigkeit eines binären Klassifikationsmodells zu bewerten?
  12. Wie könntest du mit matplotlib oder seaborn ein Histogramm erstellen?
  13. Erkläre den Unterschied zwischen merge und join in Pandas.
  14. Was sind Generatoren in Python und wie unterscheiden sie sich von normalen Funktionen?
  15. Wie verwendest du die apply-Methode in Pandas?
  16. Was ist „Feature Engineering“ und warum ist es wichtig?
  17. Wie würdest du in Python Daten von einer Webseite scrapen?
  18. Wie kann man in Pandas Duplikate in einem DataFrame finden und entfernen?
  19. Erkläre List Comprehension in Python.
  20. Was ist der Unterschied zwischen Supervised und Unsupervised Machine Learning?

Antworten

  1. Listen sind veränderlich, während Tuples unveränderlich sind.
  2. Mit der fillna() Methode oder durch Verwendung von dropna().
  3. matplotlib ist eine niedrigere Ebene und bietet mehr Anpassungsfähigkeit, während seaborn höherer Ebene ist und mehr vordefinierte Plots bietet.
  4. iloc verwendet Ganzzahlenindizes, während loc Labelindizes verwendet.
  5. Mit Bibliotheken wie sqlite3 oder SQLAlchemy.
  6. Es bezeichnet ein Modell, das zu gut auf Trainingsdaten passt und schlecht auf neue Daten generalisiert.
  7. Eine Serie ist eindimensional, während ein DataFrame zweidimensional ist.
  8. Sie gruppiert den DataFrame anhand einer bestimmten Spalte.
  9. Mit der pd.to_datetime() Funktion.
  10. Lambda ermöglicht die Erstellung anonymer Funktionen. Es wird oft mit Funktionen wie map() oder filter() verwendet.
  11. Die Area Under the Curve (AUC) oder der F1-Score.
  12. Mit plt.hist(data) oder sns.histplot(data).
  13. Beide führen Tabellen zusammen, aber merge tut dies basierend auf Spalten, während join dies basierend auf Indizes tut.
  14. Generatoren produzieren Iteratoren, geben aber nicht sofort alle Werte zurück. Sie verwenden das yield Schlüsselwort.
  15. Um eine Funktion entlang des DataFrame zu verwenden.
  16. Es beinhaltet das Erstellen oder Transformieren von Merkmalen (Features) zur Verbesserung des Modelltrainings.
  17. Mit Bibliotheken wie BeautifulSoup oder Scrapy.
  18. Mit duplicated() zum Finden und drop_duplicates() zum Entfernen.
  19. Es ist eine kompakte Methode, um Listen zu erstellen: [x for x in range(10)].
  20. Supervised Learning verwendet gelabelte Daten zum Training, während Unsupervised Learning das nicht tut und versucht, Muster oder Zusammenhänge in den Daten zu finden.

Jetzt, wo du eine Vorstellung von den Fragen hast, lass uns einige reale Use-Cases durchgehen und sehen, wie du sie mit Python lösen kannst.

Datenanalyse mit Python – Von der Problemstellung zur Lösung

Daten sind das neue Gold, und Python ist der Spaten, mit dem wir dieses Gold fördern können. Es gibt zahlreiche Bibliotheken in Python, mit denen wir eine breite Palette von datenbezogenen Aufgaben bewältigen können, von der einfachen Datenbereinigung bis hin zur Deep Learning Modellierung.

Top 10 Python-Pakete für Datenanalyse

  1. Pandas
    Vorteile: Mächtig für Datenmanipulation und -analyse, unterstützt unterschiedliche Dateiformate
    Nachteile: Kann bei sehr großen Datensätzen langsam sein.
  2. NumPy
    Vorteile: Unterstützt numerische Operationen, optimiert für mathematische Berechnungen
    Nachteile: Nicht so intuitiv wie Pandas für Datenmanipulation.
  3. Matplotlib
    Vorteile: Vielseitig für Datenvisualisierung, hohe Anpassungsfähigkeit
    Nachteile: Nicht so modern und ansprechend wie einige neuere Bibliotheken.
  4. Seaborn
    Vorteile: Aufbauend auf Matplotlib, bietet schönere Grafiken und leichter zu verwenden
    Nachteile: Weniger anpassbar als Matplotlib.
  5. Scikit-learn
    Vorteile: Umfangreiches Toolkit für maschinelles Lernen, gute Dokumentation
    Nachteile: Nicht für Deep Learning geeignet.
  6. Statsmodels
    Vorteile: Unterstützt viele statistische Modelle, gut für Hypothesentests
    Nachteile: Weniger intuitiv als andere Pakete.
  7. TensorFlow und Keras
    Vorteile: Mächtig für Deep Learning, flexibel
    Nachteile: Steile Lernkurve für Einsteiger.
  8. SQLAlchemy
    Vorteile: ORM für Datenbankabfragen, unterstützt viele Datenbank-Backends
    Nachteile: Overhead gegenüber rohen SQL-Abfragen.
  9. BeautifulSoup
    Vorteile: Toll für Web-Scraping, einfache Syntax
    Nachteile: Nicht so schnell wie Scrapy.
  10. Scrapy
    Vorteile: Schnell und mächtig für Web-Scraping, asynchron
    Nachteile: Komplexer als BeautifulSoup.

In diesem Beitrag werden wir 10 alltägliche Szenarien in der Datenwelt durchgehen und demonstrieren, wie Python diese effizient löst.

Use-Case 1: Kundenanalyse

Problemstellung: Ein Unternehmen möchte die Top-Kunden identifizieren, die in den letzten sechs Monaten den höchsten Umsatz generiert haben.

Dies hilft dem Unternehmen, seine treuesten Kunden zu belohnen oder gezielte Marketingaktionen durchzuführen.

import pandas as pd
# Load dataset
data = pd.read_csv('customer_purchase_data.csv')
# Filter purchases from the last six months
recent_purchases = data[data['date'] > '2023-04-01']
# Sum purchases by customer
top_customers = recent_purchases.groupby('customer_id').sum().sort_values('purchase_value', ascending=False)
print(top_customers.head(5))

Warum diese Lösung gut ist: Pandas ermöglicht es uns, Daten schnell zu filtern, zu gruppieren und zu sortieren. Mit nur wenigen Zeilen Code können wir wertvolle Kundeninformationen extrahieren.


Use-Case 2: Produktbewertungen

Problemstellung: Ein Online-Shop möchte die Produkte mit den meisten negativen Bewertungen identifizieren, um die Produktqualität zu verbessern.

# Load data
data = pd.read_csv('product_reviews.csv')
# Filter products with less than 3 stars
low_rated_products = data[data['rating'] < 3]
# Count occurrences of each low-rated product
product_counts = low_rated_products['product_id'].value_counts()
print(product_counts.head(5))

Warum diese Lösung gut ist: Indem wir negative Bewertungen zählen und sortieren, können wir sofort sehen, welche Produkte die meiste negative Aufmerksamkeit erhalten und Maßnahmen ergreifen.


Use-Case 3: Zeitreihenanalyse

Problemstellung: Ein Energieunternehmen möchte den zukünftigen Stromverbrauch prognostizieren.

from statsmodels.tsa.holtwinters import ExponentialSmoothing
import matplotlib.pyplot as plt
# Prepare data
timeseries = data.set_index('date')['power_consumption']
# Train model
model = ExponentialSmoothing(timeseries, trend="add").fit()
# Forecast for the next month
forecast = model.forecast(30)
# Visualization
plt.plot(timeseries.index, timeseries.values, label='Actual Consumption')
plt.plot(timeseries.index[-30:], forecast, color='red', linestyle='--', label='Forecast')
plt.legend()
plt.title('Power Consumption Forecast')
plt.show()

Warum diese Lösung gut ist: Mit statsmodels können wir erweiterte Zeitreihenmodelle nutzen, während matplotlib uns eine klare visuelle Darstellung der Prognose liefert.


Use-Case 4: Textanalyse

Problemstellung: Ein Medienunternehmen möchte die häufigsten Themen in Online-Artikeln herausfiltern.

from sklearn.feature_extraction.text import CountVectorizer
# Prepare data
articles = data['article_text']
# Count words
vectorizer = CountVectorizer(max_features=5, stop_words='english')
top_words = vectorizer.fit_transform(articles).toarray().sum(axis=0)
print(vectorizer.get_feature_names_out(), top_words)

Warum diese Lösung gut ist: Mit dem CountVectorizer von Scikit-learn können wir einfach die häufigsten Wörter oder Phrasen in großen Textmengen identifizieren.


Use-Case 5: Anomaly Detection

Problemstellung: Eine Bank möchte ungewöhnliche Transaktionen identifizieren.

from sklearn.ensemble import IsolationForest
# Prepare data
transactions = data[['amount', 'customer_age', 'transaction_type']]
# Train model
clf = IsolationForest(contamination=0.01).fit(transactions)
# Identify anomalies
data['anomaly'] = clf.predict(transactions)
anomalies = data[data['anomaly'] == -1]
print(anomalies)

Warum diese Lösung gut ist: Das Isolation Forest-Modell von Scikit-learn ist besonders nützlich, um Anomalien in großen Datensätzen zu erkennen, was bei der Erkennung von betrügerischen Aktivitäten hilfreich ist.


Use-Case 6: Datenvisualisierung

Problemstellung: Ein Unternehmen möchte seine monatlichen Verkaufszahlen der letzten Jahre visualisieren, um Trends und Muster zu erkennen.

import seaborn as sns
import matplotlib.pyplot as plt
# Load data
data = pd.read_csv('monthly_sales_data.csv')
# Plot
sns.lineplot(data=data, x='month', y='sales', hue='year')
plt.title('Monthly Sales Over the Years')
plt.show()

Warum diese Lösung gut ist: Seaborn, welches auf Matplotlib aufbaut, bietet eine einfachere Schnittstelle und ästhetisch ansprechende Grafiken. Es ermöglicht die Darstellung von Trends über die Zeit hinweg mit nur wenigen Zeilen Code.


Use-Case 7: Maschinelles Lernen

Problemstellung: Ein Online-Shop möchte basierend auf den bisherigen Einkaufsdaten eines Kunden vorhersagen, ob dieser in der Zukunft erneut einkaufen wird.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
# Prepare data
X = data[['total_purchases', 'avg_purchase_value', 'days_since_last_purchase']]
y = data['will_buy_again']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Train model
clf = RandomForestClassifier().fit(X_train, y_train)
# Evaluate
accuracy = clf.score(X_test, y_test)
print(f"Model Accuracy: {accuracy:.2%}")

Warum diese Lösung gut ist: Mit Scikit-learn können wir auf leistungsfähige Algorithmen zugreifen und diese mit nur wenigen Zeilen Code implementieren. Der RandomForestClassifier ist besonders geeignet für komplexe Datensätze und bietet oft gute Vorhersagegenauigkeit.


Use-Case 8: Web-Scraping

Problemstellung: Ein Reiseblogger möchte Informationen über beliebte Reiseziele von einer Website extrahieren.

import requests
from bs4 import BeautifulSoup
URL = 'https://example-travel-website.com/popular-destinations'
page = requests.get(URL)
soup = BeautifulSoup(page.content, 'html.parser')
# Extract destinations
destinations = [item.text for item in soup.find_all('h2', class_='destination-name')]
print(destinations)

Warum diese Lösung gut ist: BeautifulSoup ermöglicht es uns, Webseiteninhalte einfach zu parsen und relevante Informationen zu extrahieren. Dies ist besonders nützlich, wenn Daten nicht direkt verfügbar sind und manuell gesammelt werden müssen.


Use-Case 9: Datenbankzugriff

Problemstellung: Ein Datenanalyst möchte Daten aus einer SQL-Datenbank für seine Analyse abrufen.

from sqlalchemy import create_engine
# Connect to database
DATABASE_URL = 'postgresql://username:password@localhost:5432/mydatabase'
engine = create_engine(DATABASE_URL)
# Query data
data = pd.read_sql('SELECT * FROM sales_data', engine)

Warum diese Lösung gut ist: SQLAlchemy bietet eine flexible und effiziente Möglichkeit, Daten aus verschiedenen Datenbanken abzurufen. In Kombination mit Pandas kann man Daten direkt in einen DataFrame laden, was den Analyseprozess beschleunigt.


Use-Case 10: Deep Learning

Problemstellung: Ein Unternehmen möchte ein Bildklassifikationsmodell trainieren, um verschiedene Produkte in Bildern zu identifizieren.

import tensorflow as tf
from tensorflow import keras
# Load data
(train_images, train_labels), (test_images, test_labels) = keras.datasets.cifar10.load_data()
# Create model
model = keras.models.Sequential([
    keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Flatten(),
    keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Train model
model.fit(train_images, train_labels, epochs=10)

Warum diese Lösung gut ist: TensorFlow und Keras bieten eine einfache Schnittstelle zum Entwickeln von Deep Learning Modellen. Obwohl diese Modelle komplex sein können, erlauben diese Bibliotheken eine schnelle Entwicklung und Experimentierung.


Fazit

Python und seine reichhaltigen Datenbibliotheken bieten uns mächtige Werkzeuge, um gängige datenbezogene Herausforderungen zu bewältigen. Von der Datenreinigung über die Analyse bis hin zur Modellierung – mit Python können wir datengesteuerte Entscheidungen effizient treffen und umsetzen.

Fazit: Python bietet eine reiche Landschaft von Tools und Bibliotheken für Datenanalyse. Es ist ein ständiges Lernen und Entdecken. Hoffentlich hilft euch dieser Beitrag auf eurer Datenanalyse-Reise mit Python. Viel Erfolg und fröhliches Coden!

Hast du Intersse an Python und AI ? Dann bewirb dich jetzt bei uns mit einem Pull Request auf Github in unserem AI Comedy Club.

ai comedy club
«
»
Avatar von Florian Zyprian

Neueste Artikel