Pandas

Pandas ist eine Datenanalysebibliothek; sie beruht auf NumPy

import pandas as pd

Series und DataFrame

Series: Sammlung von gleichartigen Einträgen zu bestimmten Schlüsseln (Tabellenspalte)
DataFrame: Sammlung von zusammengehörenden Series-Objekten (ganze Tabelle)

Beispiel:

	Area	Population	Capital
CN	9.6	1386	Beijing
RU	17	144	Moscow
US	9.8	327	Washington, D.C.

Series erstellen

area = pd.Series({'CN': 9.6, 'RU': 17, 'US': 9.8})
population = pd.Series({'CN': 1386, 'RU': 144, 'US': 327})

area = pd.Series([9.6, 17, 9.8], ["CN", "RU", "US"])
population = pd.Series([1386, 144, 327], ["CN", "RU", "US"])

Werte auslesen

auslesen eines Werts anhand des Index-Werts:

area['CN'] # 9.6

Datentypen

Jede series hat einen bestimmten Datentyp

area.dtype # float64

manuelles Setzen des Datentyps:

area = pd.Series(
    {"CN": 9.6, "RU": 17, "US": 9.8}, dtype="float32"
)

DataFrame

countries = pd.DataFrame(
    {"area": area, "population": population}
)

Daten importieren und exportieren

CSV importieren

Beispiel: Euribor (Zinsen für europäische Anleihen)

euribor = pd.read_csv(
    "https://raw.githubusercontent.com/datasets/euribor/master/data/euribor-12m-monthly.csv"
)

CSV importieren

Fortgeschrittenes Euribor-Beispiel:

Parsen des Datums
Datum als Index verwenden
Nur die Spalten date und rate importieren

euribor = pd.read_csv(
    "https://raw.githubusercontent.com/datasets/euribor/master/data/euribor-12m-monthly.csv",
    parse_dates=["date"],
    index_col="date",
    usecols=["date", "rate"]
)

CSV importieren

mögliche Lösungen:

sp500 = pd.read_csv(
    "https://raw.githubusercontent.com/datasets/s-and-p-500/main/data/data.csv",
    index_col="Date",
    parse_dates=["Date"],
)
iris = pd.read_csv(
    "http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data",
    header=None,
    names=["sepal_length", "sepal_width", "petal_length",
           "petal_width", "species"],
)
titanic = pd.read_csv(
    "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv",
    index_col="PassengerId",
)

Importieren und Exportieren von HDF5-Daten

benötigt PyTables (Name des Pakets: tables)

euribor.to_hdf("data.hdf5", "euribor")
sp500.to_hdf("data.hdf5", "sp500")

euribor = pd.read_hdf("data.hdf5", "euribor")

Beispieldaten

Statistische Grundwerte

titanic["Age"].describe()

count    714.000000
mean      29.699118
std       14.526497
min        0.420000
25%       20.125000
50%       28.000000
75%       38.000000
max       80.000000
Name: Age, dtype: float64

(Siehe nächste Folie für Erklärungen)

Statistik einer Series

titanic["Age"].describe()

obiges berechnet die folgenden Daten:

.count()
.mean()
.std()
.quantile(0) or .min()
.quantile(0.25)
.quantile(0.5) or .median()
.quantile(0.75)
.quantile(1) or .max()

Statistiken

Liste einzigartiger Werte:

titanic["Pclass"].unique()

[2, 3, 1]

Zählen einzelner Vorkommen:

titanic["Pclass"].value_counts()

3    491
1    216
2    184

Spalten auswählen

eine Spalte (als Series) auswählen:

titanic["Age"]

mehrere Spalten (als DataFrame) auswählen:

titanic[["Name", "Age"]]

Spalten auswählen

kürzere Notation (funktioniert nicht für alle Spaltennamen):

titanic.Age

Fälle, in denen die kürzere Notation nicht verwendet werden kann:

df["first name"]  # space in name
df["class"]       # reserved word
df["mean"]        # existing method

Zeilen nach Indexwert auswählen

einzelne Zeile als Series:

sp500.loc["1872-01-01"]

mehrere Zeilen als DataFrame (beide Grenzen inklusive):

sp500.loc["1872-01-01" : "1872-12-31"]

Zeilen nach Indexwert auswählen

wenn die Indexspalte als Datum geparsed wurde:

sp500.loc["2009"]

Zeilen nach Zeilennummer auswählen

einzelne Zeile als Series:

sp500.iloc[0]

mehrere Zeilen als DataFrame:

sp500.iloc[0 : 10]

Zeilen auswählen

titanic[titanic["Pclass"] == 1]

titanic[titanic["Age"] >= 70]

Lösung: S&P 500

sp500_max = sp500["SP500"].max()
# returns a DataFrame
sp500_max_row = sp500[sp500["SP500"] == sp500_max]

kürzere Alternative: (via .idxmax()):

# returns a Series
sp500_max_row = sp500.loc[sp500["SP500"].idxmax()]

Zeilen auswählen

Grundlegende Methode:

titanic[titanic["Pclass"] == 1]

titanic[titanic["Age"] >= 70]

Zeilen auswählen: fortgeschritten

männliche Passagiere in der zweiten oder dritten Klasse:

titanic[(titanic["Pclass"] >= 2) & (titanic["Sex"] == "male")]

Passagiere, die in Southampton oder Queenstown an Bord gingen:

titanic[titanic["Embarked"].isin(["S", "Q"])]

Zeilen auswählen: fortgeschritten

titanic.query("Pclass >= 2 and Sex == 'male'")

titanic.query("Embarked in ['S', 'Q']")

Lösungen: Titanic

erwachsene (>= 18) Männer, sortiert nach Alter:

titanic[
    (titanic["Age"] >= 18) & (titanic["Sex"] = "male")
].sort_values("Age")

erwachsene Überlebende:

titanic[(titanic["Age"] >= 18) & (titanic["Survived"] == 1)]

Lösungen: Iris-Blüten

iris.sort_values(by="petal_length")

iris[iris["species"] == "Iris-setosa"].sort_values(
    by="petal_length"
)

Einfacher Plot mit Pyplot

grundlegende Funktionalität von pyplot:

import numpy as np
import matplotlib.pyplot as plt

x = np.array([0, 1, 2, 3])

y1 = x*2
y2 = x**2

plt.plot(x, y1)
plt.plot(x, y2)

Optionen für das Plotting

Beispiel für Pyplot-Optionen:

plt.plot(x, y1, color="C3", marker="X", linestyle="dashed")

Liniendiagramm

Beispiele:

euribor.plot.line()

sp500["SP500"].plot.line()

Säulendiagramm

Beispiel:

euribor.iloc[-12:].plot.bar()

Übung: Stelle den Median der sepal-width und sepal-length für alle drei Arten von Blumen dar

Scatter plot

iris.plot.scatter(
    x="sepal_length",
    y="sepal_width",
)

mit Größe (s) und Farbe (c):

iris.plot.scatter(
    x="sepal_length",
    y="sepal_width",
    s="petal_length",
    c="petal_width"
)

Übung: Scatter plot für iris setosa

Pie chart

data = pd.Series({"a": 50, "b": 30, "c": 20})
data.plot.pie(ylabel="Data")

Verteilung von Titanic-Passagieren in Klassen (1 - 3):

titanic["Pclass"].value_counts().plot.pie()

Spalten umbenennen

df.columns = ["name1", "name2"]

Daten entfernen

Zeilen entfernen:

sp500_new = sp500.drop(["1871-01-01", "1871-02-01"])

Spalten entfernen:

sp500_new = sp500.drop(columns=["Real Earnings", "PE10"])

Konvertieren von Daten

Konvertieren von Typen:

titanic["Survived"] = titanic["Survived"].astype("bool")

Ersetzen von Werten:

titanic["Female"] = titanic["Sex"].replace(
    {"female": True, "male": False}
)

Abgeleitete Werte berechnen

Hinzufügen einer neuen Spalte:

iris["sepal_ratio"] = iris["sepal_length"] / iris["sepal_width"]

iris["sepal_ratio"].mean()
iris["sepal_ratio"].std()

iris_setosa = iris.loc[
    iris["name"] == "Iris-setosa"
]

iris_setosa["sepal_ratio"].mean()
iris_setosa["sepal_ratio"].std()

Abgeleitete Werte berechnen

sp500["Diff"] = sp500["SP500"].diff()
sp500["Gain"] = sp500["Diff"] / sp500["SP500"]

Abgeleitete Werte berechnen mittels eigenen Funktionen

def classifier(age):
    if age < 18:
        return "youth"
    elif age < 60:
        return "adult"
    else:
        return "senior"

titanic["AgeCls"] = titanic["Age"].apply(classifier)

(effizientere Alternative: pd.cut())

Einzelne Daten setzen

iris.iloc[0, 0] = 6

iris.loc[:, "sepal_ratio"] = float('nan')

Fehlende Daten

titanic["Age"].shape
# (891,)

titanic["Age"].count()
# 714

Fehlende Daten

Anzeigen aller Zeilen mit fehlenden age-Einträgen:

titanic[titanic["Age"].isna()]

Fehlende Daten

Entfernen aller Zeilen mit fehlenden Daten:

titanic = titanic.dropna()

Entfernen aller Zeilen mit fehlenden Daten in der Spalte age:

titanic = titanic.dropna(subset=["Age"])

Ersetzen fehlender Daten

Ersetzen fehlender Daten durch Nullen:

titanic["Age"] = titanic["Age"].fillna(0)

Ersetzen fehlender Daten durch den letzten gültigen Wert:

titanic["Age"] = titanic["Age"].fillna(method="ffill")

Ersetzen fehlender Daten durch den nächsten gültigen Wert:

titanic["Age"] = titanic["Age"].fillna(method="bfill")

Interpolieren von Werten

data = pd.Series(
    [1, 2, 4, np.nan, 16, 32, np.nan, np.nan, 256]
)

data.interpolate("nearest")
data.interpolate("linear") # default
data.interpolate("slinear")
data.interpolate("quadratic")
data.interpolate("cubic")

Interpolieren von Werten

Lösung:

interest = pd.DataFrame({
    "us": sp500["Long Interest Rate"],
    "eu": euribor["rate"]
})

interest["eu"] = interest["eu"].interpolate("slinear")
interest = interest.dropna()

Date	Country	Exchange rate
1971-01-01	Australia	0.894
1971-02-01	Australia	0.890
1971-03-01	Australia	0.890

Multi-Index

Importieren mit Multi-Index:

exchange_rates = pd.read_csv(
    "https://datahub.io/core/us-euro-foreign-exchange-rate/r/monthly.csv",
    index_col=["Country", "Date"],
    parse_dates=["Date"])

Multi-Index

In manchen Fällen kann durch einen Multi-Index eine Series anstatt eines DataFrames verwendet werden:

exchange_rates_series = exchange_rates["Exchange rate"]

Multi-Index

Abfragen des ersten Teils eines Multi-Index (gitbt eine Series mit nur dem restlichen Index zurück):

exchange_rates_series.loc["France"]

Abfragen mehrerer Teile des Index:

exchange_rates_series.loc["France", "1971-01-01":"1971-12-31"]

Multi-Index

Abfragen in einem DataFrame:

exchange_rates.loc[("Australia", "1990"), :]
exchange_rates.loc[(slice(None, None), "1990-01-01"), :]

Bemerkung: x[a:b] ist in Python äquivalent zu x[slice(a, b)]

Bemerkung: die Date-Spalte könnte aus dem Index via reset_index entfernt werden

Joins

Joins anhand des Index bei Series-Objekten:

outer Join:

interest_rates = pd.DataFrame({
    "usd": sp500["Long Interest Rate"],
    "eur": euribor["rate"]
})

inner Join:

interest_rates = pd.DataFrame({
    "usd": sp500["Long Interest Rate"],
    "eur": euribor["rate"]
}).dropna()

Joins

Joins anhand des Index bei DataFrame-Objekten:

inner Join:

pd.merge(sp500, euribor, left_index=True, right_index=True)

outer Join:

pd.merge(sp500, euribor, left_index=True, right_index=True,
         how="outer")

Joins

Join anhand bestimmter Spalten (nicht anhand des Index):

sp500_no_index = pd.read_csv(
    "https://datahub.io/core/s-and-p-500/r/data.csv",
    parse_dates=["Date"],
)
euribor_no_index = pd.read_csv(
    "https://datahub.io/core/euribor/r/euribor-12m-monthly.csv",
    parse_dates=["date"],
    usecols=["date", "rate"]
)

pd.merge(sp500_no_index, euribor_no_index, left_on="Date",
         right_on="date")

Joins

Kurzform, wenn zugehörige Spalten gleiche Namen haben:

pd.merge(sp500_no_index, euribor_no_index, on="date")

Resultat hat eine date-Spalte statt zwei

Übung

Lösung:

gdp = pd.read_csv(
    "https://raw.githubusercontent.com/owid/owid-datasets/master/datasets/Maddison%20Project%20Database%202020%20(Bolt%20and%20van%20Zanden%20(2020))/Maddison%20Project%20Database%202020%20(Bolt%20and%20van%20Zanden%20(2020)).csv",
    index_col=["Entity", "Year"]
)
gdp_series = gdp["GDP per capita"]
gdp_2018 = gdp_series[:, 2018]

vac = pd.read_csv(
    "https://raw.githubusercontent.com/owid/covid-19-data/master/public/data/vaccinations/vaccinations.csv",
    index_col=["location", "date"]
)
vac_series = vac["total_vaccinations_per_hundred"]
vac_2021_08 = vac_series[:, "2021-08-01"]

data = pd.DataFrame({"gdp": gdp_2018, "vaccinations": vac_2021_08}).dropna()
data.plot.scatter(x="gdp", y="vaccinations")

Gruppierung und Aggregation

Anzahl von Passagieren pro Klasse:

titanic["Pclass"].value_counts()

# 3    491
# 1    216
# 2    184

Gruppierung und Aggregation

Mediane aller numerischen Werte der Passagiere je Klasse:

titanic.groupby("Pclass").median()

Median der Alter pro Klasse:

titanic.groupby("Pclass")["Age"].median()

# 1    37.0
# 2    29.0
# 3    24.0

Gruppierung und Aggregation

Anzahl der Passagiere nach Klasse und Geschlecht (Kontingenztabelle oder Kreuztabelle)

pd.crosstab(titanic["Pclass"], titanic["Sex"])

sex     female  male
pclass
1           94   122
2           76   108
3          144   347

Gruppierung und Aggregation

Durchschnittliches Alter nach Geschlecht und Klasse:

pd.crosstab(
    index=titanic["Pclass"],
    columns=titanic["Sex"],
    values=titanic["Age"],
    aggfunc=np.mean)

pd.pivot_table(
    data=titanic,
    values="Age",
    index=["Pclass"],
    columns=["Sex"],
    aggfunc=np.mean)

Übungen

Durchschnittswerte der Iris-Daten basierend auf dem Namen der Art

Durchschnittliche USD-Wechselkurse für jede Währung in den 90ern basierend auf den folgenden Daten:

exchange_rates = pd.read_csv(
    "https://datahub.io/core/us-euro-foreign-exchange-rate/r/monthly.csv",
    index_col=["Country", "Date"],
    parse_dates=["Date"])

Übungen - Lösungen

iris.groupby("species").mean()

er_90s = exchange_rates.loc[
    (exchange_rates["Date"] >= "1990-01-01") &
    (exchange_rates["Date"] <= "1999-12-31")
]

er_90s_means = er_90s.groupby("Country").mean()

Übung: Movielens

Basierend auf dem Movielens-Datensatz, finde die top-bewerteten Filme, die von zumindest 10 Nutzern bewertet wurden

ratings = pd.read_csv(
    "https://files.grouplens.org/datasets/movielens/ml-100k/u.data",
    sep="\t",
    header=None,
    usecols=[0, 1, 2],
    names=["user_id", "movie_id", "rating"],
)
movie_titles = pd.read_csv(
    "https://files.grouplens.org/datasets/movielens/ml-100k/u.item",
    sep="|",
    header=None,
    encoding="latin1",
    usecols=[0, 1],
    names=["movie_id", "title"],
)

Übung: Movielens - Lösung

movie_names = movie_titles.groupby("movie_id")["title"].first()
movie_mean_ratings = ratings.groupby("movie_id")["rating"].mean()
movie_num_ratings = ratings.groupby("movie_id")["rating"].count()

movie_ratings = pd.DataFrame({
  "name": movie_names,
  "mean_rating": movie_mean_ratings,
  "num_ratings": movie_num_ratings
})

movie_ratings.query(
    "num_ratings >= 10 and 4.2 < mean_rating"
).sort_values(by="mean_rating", ascending=False)

Zeitreihen

erstellen von Datumsfolgen (als Index-Objekte):

every_day = pd.date_range("2000-01-01", "2000-12-31")
last_of_each_month = pd.date_range(
    "2000-01-01", "2000-12-31", freq="M"
)
first_of_each_month = pd.date_range(
    "2000-01-01", "2000-12-31", freq="MS"
)
every_10_days = pd.date_range(
    "2000-01-01", "2000-12-31", freq="10D"
)

Resampling

sp500.resample("Y").mean()
sp500.resample("D").interpolate()

Zeitreihen

Überprüfen, ob der erste Tag jedes Monats in den S&P 500 Daten vorhanden ist:

sp500.index.equals(
    pd.date_range(
        sp500.index[0], sp500.index[-1], freq="MS"
    )
)
# True