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

Datenformate:

CSV
Excel
JSON
HDF5 (effizientes Binärformat)
Parquet (aus Apache Hadoop)
SQL tables (via SQLAlchemy)

Daten importieren und exportieren

Die folgenden Funktionen können Daten importieren / exportieren. Beim Importieren können Daten auch aus dem Internet gelesen werden.

Import: pd.read_csv, pd.read_excel, ...

Export: df.to_csv, df.to_excel, ...

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

Mögliche Schlüsselwortargumente für read_csv:

index_col: identifiziert eine Spalte, die als Index verwendet werden soll
header: übergeben des Werts None zeigt an, dass es keine Header-Zeile gibt
names: Spaltennamen zur Verwendung im neuen DataFrame
sep: Angeben anderer Trennzeichen als ein Komma
usecols: um nur bestimmte Spalten zu importieren
parse_dates: erwartet eine Liste von Spaltennamen
dtype: kann ein Dictionary sein, das Datentypen für bestimmte Spalten spezifiziert
...

Siehe auch: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html

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

Aufgabe: Importiere die folgenden Datenquellen und achte dabei auf passendes Format:

Monatliche Preise des US-Aktienindex S&P 500: https://raw.githubusercontent.com/datasets/s-and-p-500/main/data/data.csv
Wechselkurse: https://datahub.io/core/us-euro-foreign-exchange-rate/r/monthly.csv
Iris Dataset (Statistiken zu Blütengrößen von Iris-Blumen): http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data
Passagierdaten der Titanic: https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv

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 Excel-Dateien

benötigt das Paket openpyxl

lesen / schreiben eines einzelnen Excel-Sheets:

pd.read_excel
df.to_excel

lesen / schreiben eines ganzen Dokuments (inklusive Formatierung):

pd.ExcelFile
pd.ExcelWriter

siehe: Dataquest: Tutorial Using Excel with Python and Pandas

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

Quellen für Beispieldaten

https://datahub.io
seaborn data sets (klicke auf eine Datei und dann auf den raw Button)
pandas-datareader
http://lib.stat.cmu.edu/datasets/
Our world in data: allgemeine Datensätze, COVID-19 Datensätze

Beispieldaten

Iris-Blumen Datensatz: Download
Titanic Passagierdaten: Download
MNIST Ziffern-Datensatz: Download (Binärdaten)
California Housing Daten
MovieLens Datensatz

Pandas und NumPy

für viele Array-Operationen gibt es äquivalente Funktionalität auf Pandas DataFrames / Series:

df.abs()
df1 + df2
df.shape
...

Pandas und NumPy

Umwandlung in NumPy-Arrays:

df.to_numpy()
series.to_numpy()

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()

Statistische Werte

std: Standardabweichung (Standard deviation)
median: Hälfte der Werte liegt darüber, Hälfte liegt darunter
min: alle Werte sind größer als das Minimum
25%-Quantil: 25% aller Werte sind kleiner

Statistiken

Liste einzigartiger Werte:

titanic["Pclass"].unique()

[2, 3, 1]

Zählen einzelner Vorkommen:

titanic["Pclass"].value_counts()

3    491
1    216
2    184

Daten auslesen: Grundlagen

Spaltennamen und Indexwerte

df.index: Indexwerte der Zeilen
df.columns: Spaltennamen

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]

Zufällig Zeilen auswählen

df.sample() - ein zufälliger Eintrag)
df.sample(5) - fünf Einträge
df.sample(frac=0.1) - 10% aller Einträge

Übungen: S&P 500

erster Eintrag
letzter Eintrag
letzte 10 Einträge
10 zufällige Einträge
Eintrag vom 1.1.2009
Einträge aus dem Jahr 2009
Einträge mit "long interest rate" > 14
...

Lösungen: S&P 500

erster Eintrag: sp500.iloc[0]
letzter Eintrag: sp500.iloc[-1]
letzte 10 Einträge: sp500.iloc[-10:]
10 zufällige Einträge: sp500.sample(10)
Eintrag vom 1.1.2009: sp500.loc["2009-01-01"]
Einträge aus dem Jahr 2009: sp500.loc["2009-01-01": "2009-12-31"]
Einträge mit "long interest rate" > 14: sp500[sp500["Long Interest Rate"] > 14]

Aufgabe: S&P 500

wann war der S&P 500 am höchsten Wert? (Bestimme das Maximum, dann suche die zugehörige Zeile im DataFrame)

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()]

Aufgaben: Titanic

alle Überlebenden
alle 60-Jährigen
Anzahl an Überlebenden und Nicht-Überlebenden
Anzahl an Überlebenden und Nicht-Überlebenden in der ersten Klasse

Lösungen: Titanic

alle Überlebenden: titanic[titanic["Survived"] == 0]
alle 60-Jährigen: titanic[titanic["Age"] == 60]
Anzahl an Überlebenden und Nicht-Überlebenden: titanic["Survived"].value_counts()
Anzahl an Überlebenden und Nicht-Überlebenden in der ersten Klasse: titanic[titanic["Pclass"] == 1]["Survived"].value_counts()

Daten auslesen: Fortgeschritten

Daten auslesen

nach Zeile und Spalte auswählen:

df.loc["2009-01-02", "rate"]
df.iloc[5, 1]

Zeilen sortieren

series.sort_values()
df.sort_values("column_name")
df.sort_values(["col1", "col2"])
df.sort_index(ascending=False)

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']")

Übung: Titanic

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

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)]

Übungen: Iris-Blüten

Iris-Blüten, sortiert nach petal length
Iris Setosa, sortiert nach petal length

Lösungen: Iris-Blüten

iris.sort_values(by="petal_length")

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

Plotting-Grundlagen

Plotting-Funktionalität von pandas basiert auf pyplot (ähnliche Befehle)

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)

Einfacher Plot mit Pyplot

Resultat:

Arten von Plots

grundlegende Arten von Plots:

Liniendiagramm / Graph
Säulendiagramm (bar chart)
Histogramm
Box-Plot
Streudiagramm (scatter plot)
Tortendiagramm (pie chart)

Optionen für das Plotting

Beispiel für Pyplot-Optionen:

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

Plotting: Beispiele in Pandas

Plots aus Pandas

Wrapper für pyplot-Funktionen, die auf Series- und DataFrame-Objekten existieren:

data.plot() oder data.plot.line()
data.plot.bar()
data.plot.scatter()
data.plot.hist()
data.plot.box()
data.plot.pie()

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

Histogram

Übung: Histogramm der sepal length

Box plot

Übung: Box Plots aller Iris-Abmessungen

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()

Daten manipulieren

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

Aufgabe:

Analysiere die monatlichen S&P 500 Daten und berechne den monatlichen Gewinn / Verlust

Hinweis: Verwende die Methode .diff(), um die Differenz zwischen der vorherigen und der aktuellen Zeile zu berechnen

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

Werte, die fehlende Daten symbolisieren (ab pandas 1.0):

für floats: NaN (wie allgemein in Python üblich)
für andere Datentypen: NA (aus dem Pandas-Paket)

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

Übung:

Verwende die Daten aus sp500 und euribor, um die Entwicklungen der europäischen und amerikanischen Zinssätze einander gegenüberzustellen.

Bemerkung:

sp500 hat Daten für den ersten Tag jedes Monats, euribor hat daten für den ersten Arbeitstag jedes Monats

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()

Multi-Index

Index-Spalte: Spalte, anhand deren Einträge die Zeilen eindeutig identifiziert werden können

Multi-Index: Kombination aus mehreren Spalten zur eindeutigen Identifikation

Multi-Index

Beispiel: Exchange rates

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

Eine Zeile kann durch Kombination von date und country eindeutig identifiziert werden.

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

Join: Zusammenführen von mehreren DataFrames oder Series zu einem _DataFrame

Joins

Typen:

inner join
outer join
left join
right join

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

Übung: Ländervergleich (Scatter Plot):

BIP pro Kopf von 2018
COVID-19-Impfraten von 2021-08

Datenquellen:

Ü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")

Joins

siehe auch: https://jakevdp.github.io/PythonDataScienceHandbook/03.07-merge-and-join.html

Gruppierung und Aggregation

Beispiele zu den Titanic-Daten:

Anzahl der Passagiere nach Klasse
Durchschnittliches Alter nach Klasse
Anzahl der Passagiere nach Klasse und Geschlecht
Durchschnittliches Alter nach Klasse und Geschlecht

Gruppierung und Aggregation

Aggregation: Berechnung abgeleiteter Werte basierend auf mehreren Einträgen

Gruppierung und Aggregation

Funktionen und Methoden:

series.value_counts()
series.groupby() / df.groupby()
pd.crosstab()
pd.pivot_table()

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

Datentypen:

time stamp: ein Bestimmter Zeitpunkt (z.B. 1955-11-12, 10:04)
time period: eine Bestimmte Periode (z.B. November 1955)
time delta: eine Zeitdifferenz (z.B. 1 Stunde)

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"
)

Zeitreihen

Konvertieren zwischen time stamps und time periods:

.to_period()
.to_timestamp()

(funktioniert auf Index-Objekten und auf Series / DataFrame - Objekten)

Resampling

Resampling: Berechnen abgeleiteter Daten für andere Zeitintervalle

Beispiel: basierend auf monatlichen Daten:

Berechnen jährlicher Daten (z.B. Durchschnitt aller Monate eines Jahres)
Berechnen täglicher Daten (z.B. via Interpolation)

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

Cheat Sheet

Pandas Cheat Sheet: https://pandas.pydata.org/Pandas_Cheat_Sheet.pdf