Dieses Notebook ist ein Skript (Drehbuch) zur Vorstellung grundlegender Funktionen von Jupyter, Python, Pandas und matplotlib, um ein Gefühl für die Arbeit mit den Biblotheken zu bekommen. Daher ist das gewählte Beispiel so gewählt, dass wir typische Aufgaben während einer Datenanalyse bearbeiten. Inhaltlich ist diese Analyse allerdings nicht repräsentativ, da sie lediglich einfach Statistiken über ein Git-Repository darstellt.
In [1]:
"Hello World"
Out[1]:
Das Ergebnis ist sofort unter der Zelle sichtbar. Legen wir nun eine weitere Zelle an. Dies funktioniert mit dem Drücken der Taste ESC
und einem darauffolgendem Buchstaben b
. Alternativ können wir am Ende eines Notebooks eine Zelle mit Shift
+ Enter
ausführen und gleich eine neue Zelle erstellen.
Hier sehen wir gleich eine wichtige Eigenheit von Jupyter: Die Unterscheidung zwischen Befehlsmodus (erreichbar über Taste Esc
) und dem Eingabemodus (erreichbar über die Taste Enter
). Im Befehlsmodus ist die Umrahmung der aktuellen Zelle blau. Im Eingabemodus wird die Umrahmung grün. Gehen wir in den Befehlsmodus und drücken m
. Dies ändert den Zelltyp zu einer Markdown-Zelle. Markdown ist eine einfache Markup-Sprache, mit der Text geschrieben und formatiert werden kann. Damit lassen sich unsere durchgeführten Schritte direkt mit dokumentieren.
In [2]:
"Hello World"
Out[2]:
In [3]:
text = "Hello World!"
text[0]
Out[3]:
In [4]:
text[-1]
Out[4]:
In [5]:
text[2:5]
Out[5]:
In [6]:
text[:-1]
Out[6]:
Die weitere Funktionalität einer Bibliothek können wir erkunden, indem wir die Methoden und Attribute einer Klasse oder eines Objekts ansehen. Dazu schreiben wir in unserem String-Beispiel text.
und nutzen die integrierte Autovervollständigung von Jupyter mittels der Tabulatortaste Tab
, um zu sehen, welche Methoden uns aktuell verwendetes Objekt bietet. Gehen wir dann mit der Pfeiltaste unten
oder drücken z. B. die ersten Buchstaben von upper
, drücken Enter
und schließend Shift
+ Tab
, dann erscheint die Signatur des entsprechenden Funktionalität und der Ausschnitt der Hilfedokumentation. Bei zweimaligem Drücken von Shift
+ Tab
erscheint die Hilfe vollständig. Mit dem Aufruf von upper()
auf unsere text
-Variable können wir unseren Text in Großbuchstaben schreiben lassen.
In [7]:
text.upper
Out[7]:
Die interaktive Quellcode-Dokumentation hilft uns auch herauszufinden, welche Argumente wir in einer Methode zusätzlich zu normale Übergabeparametern hinzufügen können.m
In [8]:
text.split(maxsplit=2, sep=" ")
Out[8]:
In diesem Notebook wollen wir uns die Entwicklungsgeschichte des Open-Source-Projekts "Spring PetClinic" anhand der Historie des dazugehörigen Git-Repositories ein wenig genauer ansehen.
Das GitHub-Repository https://github.com/torvalds/linux/ wurde dafür über den Befehl
git clone https://github.com/torvalds/linux.git
auf die lokale Festplatte geklont.
Die für diese Auswertung relevanten Teile der Historie wurde mittels
git log --pretty="%ad,%aN" --no-merges > git_demo_timestamp_linux.csv
exportiert. Dieser Befehl liefert pro Commit des Git-Repositories den Zeitstempel des Commits (%ad
) sowie den Namen des Autors (%aN
). Die jeweiligen Werte sind kommasepariert. Wir geben zusätzlich mit an, dass wir reine Merge-Commits nicht erhalten wollen (über --no-merges
). Das Ergebnis der Ausgabe speichern wir in die Datei git_demo_timestamp_linux.csv
.
Hinweis: Für eine optimierte Demo wurden manuell noch Header und das Trennzeichen geändert, um schneller durch die Analyse zu kommen. Die Unterschiede sind unter https://www.feststelltaste.de/developers-habits-linux-edition/ zu sehen, welcher mit dem Original-Datensatz durchgeführt wurde.
In [9]:
import pandas as pd
Ob das Importieren des Moduls auch wirklich funktioniert hat, können wir prüfen, in dem wir mit dem pd
-Modul arbeiten. Dazu hängen wir an die pd
-Variable den ?
Operator an und führen die Zelle aus. Es erscheint die Dokumentation des Moduls im unteren Bereich des Notebooks. Diesen Bereich können wir durchlesen und mit der Taste ESC
auch wieder verschwinden lassen.
In [10]:
pd?
Danach lesen wir die oben beschriebene und gepackte CSV-Datei git_demo_timestamp_linux.gz
von einer URL
ein. Da es sich um eine gzip
-gepackte Datei handelt und wir diese Datei über das Web beziehen, müssen wir hier zusätzlich den verwendeten Kompressionsalgorithmus mit angeben mittels compression='gzip'
.
Das Ergebnis des Ladens speichern wir in der Variable git_log
. Hierin haben wir nun die Daten in
DataFrame
(so etwas ähnliches wie ein programmierbares Excel-Arbeitsblatt) geladen,Series
(in etwa Spalten) besteht. Auf den DataFrame
können wir nun Operationen ausführen. Z. B. können wir uns mittels head()
die fünf ersten Einträge anzeigen lassen.
In [11]:
URL = "https://raw.githubusercontent.com/feststelltaste/software-analytics/master/demos/dataset/git_demo_timestamp_linux.gz"
git_log = pd.read_csv(URL, compression="gzip")
git_log.head()
Out[11]:
Als nächstes rufen wir info()
auf den DataFrame
auf, um einige Eckdaten über die eingelesenen Daten zu erhalten.
In [12]:
git_log.info()
Den Zugriff auf die einzelnen Series können wir mittels der Schreibeweise [<spaltenname>]
oder (in den meisten Fällen) per direkter Nutzung des Namens der Series
erreichen.
In [13]:
git_log.author.head()
Out[13]:
Auch auf einer Series
selbst können wir verschiedene Operationen ausführen. Z. B. können wir mit value_counts()
die in einer Series
enthaltenen Werte zählen und nach gleichzeitig nach ihrer Häufigkeit sortieren lassen. Das Ergebnis ist wieder eine Series
, diesmal aber mit den zusammengezählten und sortieren Werten. Auf diese Series
können wir zusätzlich ein head(10)
aufrufen. So erhalten wir eine schnelle Möglichkeit, die TOP-10-Werte einer Series
anzeigen zu lassen. Das Ergebnis können wir dann in einer Variable top10
festhalten und ausgeben lassen, in dem wir die Variable in die nächste Zellenzeile schreiben.
In [14]:
top10 = git_log.author.value_counts().head(10)
top10
Out[14]:
Als nächstes wollen wir das Ergebnis visualisieren bzw. plotten. Um die das Plot-Ergebnis der intern verwendeten Plotting-Bibliothek matplotlib
direkt im Notebook anzuzeigen, müssen wir Jupyter dies mit dem Magic-Kommando
%matplotlib inline
vor dem Aufruf der plot()
Methode mitteilen.
Standardmäßig wird beim Aufruf von plot()
auf einen DataFrame
oder einer Series
ein Liniendiagramm erstellt.
In [15]:
%matplotlib inline
top10.plot()
Out[15]:
Das macht hier wenig Sinn, weshalb wir mittels einer Untermethode von plot
namens bar()
ein Balkendiagramm erzeugen lassen.
In [16]:
top10.plot.bar()
Out[16]:
Für diese Daten bietet sich auch eine Visualisierung als Tortendiagramm an. Hierfür rufen wir statt bar()
die Methode pie()
auf.
In [17]:
top10.plot.pie()
Out[17]:
Das Diagramm sieht hier jedoch nicht sehr schön aus.
Mit den optionalen Styling-Parametern können wir erreichen, dass wir eine schönere Grafik angezeigt bekommen. Wir verwenden dazu
figsize=[7,7]
als Größenangabetitle="Top 10 Autoren"
als Titellabels=None
, um die überflüssige Beschriftung nicht anzuzeigen.
In [18]:
top10.plot.pie(
figsize=[7,7],
title="Top 10 Autoren",
label="")
Out[18]:
In [19]:
git_log.timestamp.head()
Out[19]:
Bevor wir in die Welt der Zeitreihenverarbeitung einsteigen können, müssen wir unsere Spalte mit den Datumsangabe zuerst in den passenden Datentyp umwandeln. Zurzeit ist unsere Spalte timestamp
noch ein String, also von textueller Natur. Wir können dies sehen, in dem wir uns mittels der Helferfunktion type(<object>)
den ersten Eintrag der timestamp
-Spalte anzeigen lassen:
In [20]:
type(git_log.timestamp[0])
Out[20]:
Beim Umwandeln von Datentypen hilft uns Pandas natürlich ebenfalls. Die Funktion pd.to_datetime
nimmt als ersten Parameter eine Series
mit Datumsangaben entgegen und wandelt diese um. Als Rückgabewert erhalten wir entsprechend eine Series
vom Datentyp Timestamp
. Die Umwandlung funktioniert für die meisten textuellen Datumsangaben auch meistens automagisch, da Pandas mit unterschiedlichesten Datumsformaten umgehen kann. Das Ergebnis schreiben wir auch gleich in die gleiche Spalte zurück.
In [21]:
git_log.timestamp = pd.to_datetime(git_log.timestamp)
git_log.head()
Out[21]:
Ob die Umwandlung erfolgreich war, können wir mit einem nochmaligen Aufruf von type()
auf den ersten Wert unserer umgewandelten Spalte timestamp_local
überprüfen.
In [22]:
type(git_log.timestamp[0])
Out[22]:
Wir können nun auch auf einzelne Bestandteile der Datumsangaben zugreifen. Dazu verwenden wir das dt
-Objekt ("datetime") und können auf dessen Eigenschaften wie etwa hour
zurückgreifen.
In [23]:
git_log.timestamp.dt.hour.head()
Out[23]:
Zusammen mit der bereits oben vorgestellten value_counts()
-Methode können wir nun wieder Werte zählen lassen. Wichtig ist hier jedoch, dass wir zusätzlich den Parameter sort=False
setzen, um die sortierung nach Mengenangaben zu vermeiden.
In [24]:
commits_je_stunde = git_log.timestamp.dt.hour.value_counts(sort=False)
commits_je_stunde.head()
Out[24]:
Das Ergebnis können wir entsprechend mittels eines Balkendiagramms ausgeben und erhalten so eine Übersicht, zu welcher Tageszeit Quellcode committet wird.
In [25]:
commits_je_stunde.plot.bar()
Out[25]:
Wir beschriften nun zusätzlich die Grafik. Dazu speichern wir uns das Rückgabeobjekt der bar()
-Funktion in der Variable ax
. Hierbei handelt es sich um ein Axes
-Objekt der darunterliegenden Plotting-Bibliothek matplotlib
, durch das wir zusätzliche Eigenschaften des Plots beliebig anpassen können. Wir setzen hier
set_title(<titelname>)
set_xlabel(<x_achsenname>)
undset_ylabel<y_achsenname>)
Als Ergebnis erhalten wir nun ein ausagekräftiges, beschriftetes Balkendiagramm.
In [26]:
ax = commits_je_stunde.plot.bar()
ax.set_title("Commits pro Stunde")
ax.set_xlabel("Tagesstunde")
ax.set_ylabel("Commits")
Out[26]:
Wir können auch nach Wochentagen auswerten. Dazu verwenden wir das weekday
-Attribut auf dem DateTime
-Attribut dt
. Wie üblich, lassen wir hier die Werte über value_counts
zählen, lassen die Werte aber nicht der Größe nach sortieren.
In [27]:
commits_je_wochentag = git_log.timestamp.dt.weekday.value_counts(sort=False)
commits_je_wochentag
Out[27]:
Das Ergebnis in commits_je_wochentag
lassen wir als ein Balkendiagramm mittels plot.bar()
ausgeben.
In [28]:
commits_je_wochentag.plot.bar()
Out[28]:
Nachfolgend wollen wir den Verlauf aller Commits über die letzten Jahre aufzeichnen lassen. Dazu setzen wir die timestamp
Spalte als Index mittels set_index(<spaltenname>)
. Zudem selektieren wir lediglich die author
-Spalte mittels [<spaltenname>]
. Dadurch arbeiten wir fortlaufend auf einer reinen Series
statt eines DataFrame
. Randnotiz: Die Verarbeitung mittels Series
folgt fast analog wie bei einem DataFrame
. Eine Series
wird jedoch nicht so schön in einer Tabelle formatiert angezeigt, weshalb ich persönlich die Bearbeitung mittels DataFrame
bevorzuge.
In [29]:
git_timed = git_log.set_index('timestamp')['author']
git_timed.head()
Out[29]:
Über die resample(<zeiteinheit>)
-Funktion des DataFrame
s können wir nun Werte nach bestimmten Zeiteinheiten gruppieren wie z. B. nach Tage (D
), Monate (M
), Quartale (Q
) oder Jahre (A
). Wir verwenden hier ein resample("D")
für tageweises zählen. Zudem geben wir noch an, wie die Einzelwerte pro Zeiteinheit zusammengeführt werden sollen. Hierzu wählen wir die count()
-Funktion, um die Anzahl der Commits für jeden einzelnen Tag zu zählen.
In [30]:
commits_per_day = git_timed.resample("D").count()
commits_per_day.head()
Out[30]:
Um den Commit-Verlauf über die Jahre hinweg aufzuzeigen, bilden wir die kumulative Summe über alle Tageseinträge mittels cumsum()
. Damit werden alle Werte nacheinander aufsummiert.
In [31]:
commits_pro_tag_kumulativ = commits_per_day.cumsum()
commits_pro_tag_kumulativ.head()
Out[31]:
Das Ergebnis plotten wir nun als Liniendiagramm und erhalten somit die Anzahl der Commits über die Jahre hinweg aufgezeichnet.
In [32]:
commits_pro_tag_kumulativ.plot()
Out[32]:
Wir haben jetzt einige Grundlagen zu Pandas kennengelernt. Damit kommen wir schon sehr weit in der täglichen Arbeit. Die anderen wichtigen Themenbereiche, die nun noch fehlen, sind:
groupby
DataFrame
s mittels pivot_table