Daten aufbereiten und visualisieren

Die erste Aufgabe gibt dir zwei DataFrames mit einer gemeinsamen Schlüsselspalte (z. B. purchase-id in ORDERS und PERSONS). Du sollst sie so verbinden, dass nur Zeilen mit einem Treffer in beiden Tabellen erhalten bleiben — das Resultat hat keine NaN-Werte.

Am Ende ist genau eine bestimmte Spaltenliste vorgegeben (z. B. products, purchase-id, name, birthdate). Die Reihenfolge ist meist die natürliche, die pd.merge sowieso liefert.

Eine Zeile reicht — du musst dich nur für den richtigen how-Wert entscheiden:

1. Beide Tabellen haben eine gemeinsame Spalte → on='spaltenname'.
2. Du willst nur Zeilen mit Match → how='inner' (das ist auch der Default, lässt sich also auch weglassen).
3. Spaltenreihenfolge stimmt automatisch — Pandas behält die linke Tabelle zuerst, hängt die rechte (ohne Schlüsselspalte) hinten dran.

• DF.copy() falsch verstanden — pd.merge gibt einen neuen DataFrame zurück; die Eingaben werden nicht mutiert. Du brauchst hier kein copy().
• how weggelassen funktioniert (inner ist Default), aber die Tests prüfen oft len(result) — wenn du mit how='outer' arbeitest, kommen NaN-Zeilen rein und die Anzahl stimmt nicht.
• Falsche Spalte für on — beide DataFrames müssen exakt diesen Spaltennamen haben. Bei Schreibfehler wirft Pandas einen KeyError. Nimm dir 5 Sekunden, um in beiden DataFrames df.columns zu prüfen.

Aufgabe 2 ist quasi Aufgabe 1 mit einem anderen how-Wert. Du sollst alle Bestellungen behalten — auch die, deren purchase-id keinen Eintrag in PERSONS hat. In solchen Zeilen werden name und birthdate zu NaN.

Identische Struktur wie Aufgabe 1 — nur how ändern:

1. pd.merge(linker, rechter, on='spalte', how='left') — how='left' bedeutet: alle Zeilen aus dem linken DataFrame bleiben erhalten.
2. Felder, die im rechten DataFrame keinen Match finden, sind im Ergebnis NaN.
3. Die Test-Zelle prüft typischerweise len(result) == len(linker_df) und result.isna().any().any() == True.

• how='right' — würde nur Zeilen aus PERSONS behalten und Bestellungen ohne Person verlieren. Falsche Richtung.
• how='outer' — würde zusätzlich Personen ohne Bestellungen hinzunehmen — mehr Zeilen, als die Aufgabe verlangt.
• how=left (ohne Anführungszeichen) — NameError, weil Python left als Variable interpretiert.

Aufgabe 3 spiegelt Aufgabe 2: jetzt sollen alle Personen im Ergebnis bleiben, auch die, die keine Bestellung aufgegeben haben. Bei diesen Personen werden products und purchase-id-Felder zu NaN.

Drittes Mal dasselbe Schema — diesmal mit how='right':

pd.merge(ORDERS, PERSONS, on='purchase-id', how='right')

Man könnte das auch durch ein Vertauschen der Argumente erreichen: pd.merge(PERSONS, ORDERS, on='purchase-id', how='left') — funktional identisch. Die HSG-Aufgabe gibt aber meist eine Spaltenreihenfolge vor, also folge dem Beispiel der Aufgabe.

• Spaltenreihenfolge — bei how='right' kommen die Spalten aus ORDERS zuerst, dann die aus PERSONS (ohne Schlüssel). Falls die Aufgabe eine andere Reihenfolge will, explizit auswählen: result[['col_a', 'col_b', 'col_c', 'col_d']].
• Anzahl Zeilen ≠ len(PERSONS) — wenn eine Person mehrere Bestellungen hat, vervielfacht sich ihre Zeile im Right-Merge. Das ist normal und vom Test meistens erwartet.

Aufgabe 4 (oft als optional markiert) gibt dir eine Spalte, in der pro Zeile ein Python-Dict steht — z. B. {'apple': 2, 'book': 1, 'chair': 1}. Du sollst eine neue Spalte anhängen, die die Summe der Werte (also die Gesamtanzahl Items) pro Zeile enthält.

Wichtig: das Original darf nicht verändert werden, das Ergebnis ist ein neuer DataFrame.

Drei Schritte:

1. work = df.copy() — Original schützen.
2. Auf der Dict-Spalte mit .apply(...) über alle Zeilen laufen. Pro Zeile bekommt die Lambda-Funktion das Dict als Argument; sum(d.values()) ist die Anzahl Items.
3. Das Resultat als neue Spalte zuweisen: work['product_count'] = work['products'].apply(...).

Tipp: wenn die Dict-Spalte als String gespeichert ist (z. B. nach einem CSV-Import), brauchst du noch json.loads(...) davor — das ist der HSG-Hinweis auf JSON.

• In-place mutieren — wenn du df['product_count'] = ... schreibst, mutierst du den globalen ORDERS. Andere Testzellen scheitern dann scheinbar grundlos. Erst copy(), dann zuweisen.
• .map() statt .apply() — bei einer Spalte mit Dicts funktioniert beides; idiomatisch ist .apply() für komplexere Operationen pro Zeile.
• String statt Dict in der Spalte — wenn die Spalte ein CSV-Import ist, sind die Dicts oft nur Strings. Dann: work['products'].apply(json.loads).apply(lambda d: sum(d.values())) (zwei applys, oder einer kombiniert mit Lambda).

Aufgabe 5 ist die klassische Spezies-Statistik auf dem IRIS-Datensatz. Zwei Varianten:

• 5.1: Eine Aggregation (Mittelwert) über mehrere Spalten — Ergebnis: ein DataFrame mit species als Index und einer Zeile pro Spezies.
• 5.2: Mehrere Aggregationen pro Spalte (z. B. min und max für petal_length) — Ergebnis hat einen Multi-Index in den Spalten.

5.1 — eine Zeile reicht:

IRIS.groupby('species').mean()

5.2 — agg(...) mit einem Dict, wenn pro Spalte unterschiedliche Aggregationen gewünscht sind:

IRIS.groupby('species').agg({
    'sepal_length': 'mean',
    'petal_length': ['min', 'max'],   # zwei Aggregationen → Multi-Index
    'petal_width':  'median',
    'sepal_width':  'std',
})

Wichtig: das Ergebnis hat species als Index (nicht als Spalte) — falls der Test species als Spalte verlangt, hängst du .reset_index() an.

• .mean() auf nicht-numerischen Spalten — bevor pandas 2.0 mussten manchmal nicht-numerische Spalten ausgewählt werden. Mit aktuellen Pandas-Versionen ignoriert .mean() Object-Spalten standardmäßig. Falls eine Warnung kommt: nur numerische Spalten selektieren oder numeric_only=True.
• Multi-Index in den Spalten ignoriert — das Test-Cell prüft oft list(result.columns) und erwartet Tupel wie ('petal_length', 'min'). Falls dein Resultat flache Strings hat, hast du wahrscheinlich agg(['min', 'max']) ohne Dict geschrieben — dann verschwindet der Multi-Index.
• reset_index() zu früh aufgerufen — kostet dich den Index, den der Test aber als Index erwartet.

Aufgaben 6.x bauen drei verschiedene Plots auf einem kleinen fruits-DataFrame (Wochenkonsum von Apple, Banana, Cherry):

• 6.1: Liniendiagramm — drei farbige Linien (grün/blau/rot), eine pro Frucht.
• 6.2: Gruppiertes Balkendiagramm — drei Balken pro Wochentag, leicht versetzt.
• 6.3: Drei vertikal gestapelte Subplots, einer pro Frucht, mit gemeinsamen Achsen.

Diese Aufgaben haben keine Test-Zelle — du vergleichst dein Resultat visuell mit dem vorgegebenen Bild.

6.1 — eine Linie pro Frucht:

fig, ax = plt.subplots(figsize=(8, 6))
ax.plot(fruits.columns, fruits.loc['Apple'],  color='green', label='Apple')
ax.plot(fruits.columns, fruits.loc['Banana'], color='blue',  label='Banana')
ax.plot(fruits.columns, fruits.loc['Cherry'], color='red',   label='Cherry')
ax.legend()
plt.show()

6.2 — drei Balken pro Wochentag, versetzt um width:

import numpy as np
xticks = np.arange(len(fruits.columns))
w = 0.3
ax.bar(xticks - w, fruits.loc['Apple'],  width=w, color='green')
ax.bar(xticks,     fruits.loc['Banana'], width=w, color='blue')
ax.bar(xticks + w, fruits.loc['Cherry'], width=w, color='red')
ax.set_xticks(xticks)
ax.set_xticklabels(fruits.columns)

6.3 — drei Subplots, gestapelt, geteilte Achsen:

fig, (apple_ax, banana_ax, cherry_ax) = plt.subplots(
    nrows=3, ncols=1, figsize=(8, 6), sharex=True, sharey=True
)
apple_ax.bar(fruits.columns,  fruits.loc['Apple'],  color='green')
banana_ax.bar(fruits.columns, fruits.loc['Banana'], color='blue')
cherry_ax.bar(fruits.columns, fruits.loc['Cherry'], color='red')

• width zu groß — bei drei Balken pro Tag muss 3 × width ≤ 1 gelten. Bei width=0.5 überlappen sich Balken benachbarter Tage. 0.3 ist sicher.
• set_xticks vor set_xticklabels — diese Reihenfolge gilt; sonst ignoriert matplotlib die Labels.
• plt.plot und ax.plot mischen — bleib bei ax.xxx, sobald du eine Figure mit plt.subplots() erzeugst. Sonst landen einige Elemente auf der falschen Achse.

Aufgaben 7.x verwenden den IRIS-Datensatz wieder, jetzt mit Seaborn (Importiert als sns):

• 7.1: Pro Spezies einen Boxplot der vier Features (sepal/petal length/width). Drei Subplots nebeneinander, geteilte Achsen.
• 7.2: Für jede Kombination aus zwei Features einen Regressionsplot (kubisch, order=3). Insgesamt sechs Plots untereinander gestapelt.

7.1 — eine Schleife über die drei Spezies, einen Boxplot pro Subplot:

fig, axes = plt.subplots(ncols=3, figsize=(16, 6), sharex=True, sharey=True)
for i, flower in enumerate(sorted(IRIS.index.unique())):
    sns.boxplot(data=IRIS.loc[flower], ax=axes[i])
    axes[i].set_title(flower.title())
plt.show()

7.2 — itertools.combinations über die Spalten, dann pro Paar ein regplot:

from itertools import combinations
features = list(combinations(IRIS.columns, 2))   # 6 Paare bei 4 Spalten
fig, axes = plt.subplots(nrows=len(features), figsize=(12, 25))
for i, (feat_a, feat_b) in enumerate(features):
    sns.regplot(x=IRIS[feat_a], y=IRIS[feat_b], order=3, ax=axes[i])
plt.subplots_adjust(top=1)
plt.show()

• itertools.combinations vs itertools.permutations — bei vier Spalten liefern combinations(cols, 2) sechs Paare (ungeordnet); permutations wären zwölf. Das Bild zeigt sechs Plots — also combinations.
• Achsen verstecken — wenn die X-Achsen-Beschriftung der oberen Subplots vom Plot darunter verdeckt wird, hilft plt.subplots_adjust(top=1) oder figsize deutlich höher setzen.
• ax=axes[i] vergessen — ohne ax-Argument zeichnet Seaborn auf eine neue Figure, nicht in dein Subplot-Gitter.