Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Paisen-Podcast in der mittlerweile sechsten Episode.
Heute geht es um Pandas. Ja, was machen wir eigentlich? Wir sind, wie fast immer, in Jochens Wintergarten.
Ich bin der Dominik, dabei ist wie immer der Jochen und mein Gast, der Simon.
Ja, hallo Simon.
Hi.
Genau, vielleicht kannst du dich einfach mal kurz vorstellen, bevor wir über das Thema reden.
Klar. Ja, ich bin Simon. Ich bin von Haus aus Biologe, immer mit Interesse für Informatik und Spieleentwicklung gesegnet gewesen und habe das dann irgendwie auch zu meinem Beruf gemacht.
Also ich habe nach meinem Bio-Studium ein bisschen geforscht in der Bio-Informatik. Da ging es dann viel um Datenanalyse von DNA-Sequenzen und so Dingen.
Game of Life.
Game of Life, ja, quasi. Nur in echt echt.
Und zusammen mit dem Wissen, was ich daraus getragen habe und meinem Interesse an Informatik und Spieleentwicklung,
mache ich heute als selbstständiger IT-Trainer Trainings für Game Engines und Trainings für Softwareentwicklung und parallel noch ein paar Softwareprojekte.
Um das Gaming haben wir uns ja schon ein bisschen unterhalten, das machen wir auch nach der Folge ein bisschen intensiver.
Aber heute soll es ja um Pandas gehen.
Genau, heute...
Deswegen, ja, super, dass du das auch ganz viel mit deinem zu tun hattest in deinem Fach, in deiner Wissenschaft.
Bevor wir aber jetzt auf das Pandas-Thema eingehen,
würde ich gerne noch so ein bisschen wieder
Formalkrams abarbeiten.
Wenn ihr Fragen, Anmerkungen
habt, Lobkommentare, Hass,
dann schreibt uns doch an
hallo-podcast.de
Ihr findet natürlich die links und alle zusätzlichen Informationen
wie in den Shownotes.
Es gab noch ein bisschen User-Feedback und zwar
sollten wir irgendwann mal eine Folge machen
über Do's und Don'ts im Programmieren.
Also seid doch bitte so nett
und schickt uns einfach per E-Mail eure
Do's und eure Don'ts. Das wäre super,
dann schneiden wir das ein bisschen zusammen und fragen
euch in einer der nächsten Folgen bestimmt irgendwann mal danach.
Ja.
Doch, es gab noch ein anderes eben zu der Datenbank-
Folge, dass sie, dass das gar nicht so
schlimm gewesen wäre mit der Länge und das
ja, fand ich
auch ganz gut. Ist übrigens vielleicht ganz interessant, also wenn man sich
anguckt, welche Folgen komplett
runtergeladen wurden, dann hat die beste Quote tatsächlich
die Datenbank-Folge zur Zeit.
Was ich ein bisschen überraschend finde. Ich hätte jetzt auch erwartet,
dass es eher ein bisschen runter geht, aber ja.
Vielleicht müssen wir noch mehr so Buzzword-Bingo-Sachen machen
und dann ganz viele tolle Klickzahlen bekommen.
Nein, wir machen das natürlich für alle unsere Hörer, vor allen Dingen für die, die sich dafür wirklich interessieren und natürlich auch für die Leute, die was lernen wollen und für alle Leute, die einfach so reinhören oder denen langweilig ist oder ihr wisst ja, morgens, abends, nachts, beim Aufstehen im Flugzeug könnt ihr immer hören.
Ja, bevor wir in das Thema gehen, ist weiterhin noch ein paar News aus der Szene und zwar gab es so ein bisschen was Neues, glaube ich.
Python 3.8, zweite Alpha.
Ja.
Ja, da gab es so ein paar coole neue Sachen mit Shared Memory for Multiprocessing.
Jochen, was ist das denn?
Ja, das ist eine gute Frage.
wann habe ich denn das da reingeschrieben?
Oh, ja, das ist auch schon ein bisschen her, kann ich gar nicht.
Ah doch, ja, alles klar.
Das ist ja immer so.
Das war ja immer so ein Problem.
Also man muss ja, wenn man jetzt über mehrere Prozessoren
Berechnungen verteilen will in Python,
das auf mehreren Prozessen machen,
weil man ja irgendwie so ein Global Interpreter-Log hat,
das halt verhindert, dass man das innerhalb von einem Prozess
irgendwie mehrere Prozessoren benutzen kann.
Und ja, früher hat man halt immer so das, oder hat man jetzt immer noch in der stabilen Version, aber vielleicht hat man das mit 3.8. nicht mehr so, das Problem, dass man, wenn man jetzt eine Funktion aufrufen möchte und, sagen wir mal so, man startet halt einen Pool von 5 Prozessen oder sowas oder 10 und eben so viele üblicherweise, wie man Prozessoren hat und ruft jetzt eine Funktion auf jedem Prozessor sozusagen auf.
Also man hat jetzt eine Liste von Dingen, die man irgendwie abarbeiten möchte, man hat eine Funktion, die das dann halt tut, dann sagt man, okay, starte mit diesem Job irgendwie diese Funktion und das geht dann halt irgendwie auf jeden Prozess, der halt in diesem Pool ist, wird dann halt das irgendwie gestartet.
Also wie man im Supermarkt ganz viele verschiedene Kassen aufmacht und macht ein paar Kassen auf einmal auf.
Ja, ja, ja. Das Problem ist jetzt, dass man, wenn man da irgendwie auch Daten hat, auf denen da gearbeitet wird, dann muss man die Daten irgendwie zu diesen Prozessen bringen. Das ist jetzt ein anderer Prozess. Das heißt, man kann nicht einfach das, also im Code ist es schon so, dass man einfach einen Funktionsaufruf macht. Aber was dann im Hintergrund passieren muss, ist ja irgendwie, dass die Daten serialisiert werden. Dann müssen sie irgendwie durch die Gegend geschoben werden und dann auf der anderen Seite wieder deserialisiert werden.
In so kleine Häppchen und dass
die ganze große Bestellung an verschiedenen Kassen
abgearbeitet wird, um danach wieder in der richtigen Reihenfolge
im Einkaufskraub zu landen.
So ungefähr?
Ja, man kann...
15 Fehler wieder in einem Kasten.
Ich weiß nicht, ob die Analogie da in der Stunde
so gut passt.
Ich weiß auch nicht genau.
Ja, man
muss es, ja.
Man kann sich vielleicht vorstellen, dass man, wenn man jetzt
einen riesen Einkaufswagen voll Zeug hat
und möchte jetzt das an fünf Kassen
aber bezahlen, dann
muss man halt auch fünf Einkaufswagen haben, in die man
das jetzt aufteilt und mit jedem Einkaufswagen
einzeln zu einer Kasse und
dann muss die
irgendwer umpacken. Dann muss man die umpacken,
genau, und das ist halt alles
halbwegs aufwendig und
kann halt auch zu Problemen führen, wenn die Daten sehr groß
werden zum Beispiel, dann kann es sein, dass irgendwelche
Dinge dazwischen halt aussteigen und das ist alles
nicht so schön und
ist es halt unter Umständen auch etwas, was
Dinge langsam macht und jetzt geht es aber
transparent mit Chat-Memory sozusagen.
Das heißt, man hat halt die Daten, genau, das ist ja auch so ein Problem, wenn man jetzt Daten serialisiert und deserialisieren muss, dann kopiert man sie damit natürlich auch. Das heißt, wenn man große Daten hat, die jetzt vielleicht insgesamt nur einmal in den Hauptspeicher passen, aber nicht zweimal, wenn man sie kopiert, dann hat man sie halt zweimal drin und dann hat man so wenig Hauptspeicher, ist ja auch blöd.
Und was halt schon immer viel, viel cooler war, ist, wenn man halt einfach Shared Memory reservieren kann und sagt dann den einzelnen Prozessen, gibt denen nur einen Pointer auf diese Shared Memory und sagt so, da sind deine Datenstrukturen drin.
Also das heißt, jemand nimmt sich einfach so einen Unterkorb aus dem Einkaufswagen raus, der schon fertig ist und der Einkaufskorb, der fährt dann automatisch auf das richtige Förderband.
Ja, nee, aber das ist, ja, mal überlegen, ob man diese Analogie da noch irgendwie findet.
Ja, Shared Memory, ein eingeteilter Einkaufswagen
fällt mir jetzt auch tatsächlich schwer.
Das wäre der eine Einkaufswagen, der an allen fünf Kassen steht.
Jede Kasse greift nur auf
einen Teil von dem Korb selber zu.
Stimmt, wir haben eine Bohre von Kassen.
Die Kasse ist oben, unten, rechts und links und man kann einfach
eingreifen. Das ist schön, ja.
Genau, so könnte man sich das vorstellen, ja.
Und das heißt, man hat halt
selbst wenn man jetzt Daten hat, die
so gerade in den Hauptspeicher vielleicht passen,
dann kann man die trotzdem auf mehreren Prozessen verarbeiten.
Und das macht natürlich
Multiprocessing auf Python deutlich attraktiver und
das ist irgendwie eine ziemlich coole Geschichte, wenn ihr jetzt in 3.8
kommt. Da wird Python ja schneller.
Ja, also, oder es wird einfacher
damit, also man kann ja auch, das konnte man auch sowieso
schon immer machen, man kann ja auch einfach
Standard-Memory reservieren, da Dinge
reinpacken, da gibt es übrigens auch
ein schönes
Modul in der
Standard-Bibliothek, das heißt Struct.
Struct? Genau, damit
kann man zum Beispiel Daten
halt so binär
irgendwie in den
Hauptspeicher schreiben.
Und
das zum Beispiel so tun, dass das halt
C-Structs sind.
Und dann kann man
das halt, also das ist halt so etwas,
so haben wir das früher halt gemacht, wenn wir Daten
nicht so groß waren, dass man da nicht einfach
irgendwas mehr tun konnte.
Das heißt, man hat halt irgendwie
einen Shared-Memory-Bereich, in den schreibt man halt
irgendwie per Struct irgendwie
sozusagen C-Struct-Daten
irgendwie rein und hat dann Python-Prozesse,
die wiederum einen Pointer auf diese Shared-Memory
kriegen und
die dann halt wieder ein C-Modul
haben, das dann halt irgendwas mit den Daten macht und so.
Und dann geht das auch schon, aber es ist halt viel Handarbeit
und jetzt kriegt man das quasi so geschenkt
und das passiert alles automatisch und das ist halt
schon sehr, sehr nett.
Hört ja auch gerade diese Hintergrundmusik, das ist so ein bisschen wie
in Battlestar Galactica, diese
G...
Keine Opelide.
Ja, die nächsten News aus der Szene.
Doppelte Keys, gab es einen Post
von Guido irgendwo, der hat irgendwas geshared.
Es gibt ein neues Python-Enhancement-Proposal,
das eine ganz interessante Geschichte vorschlägt.
Und zwar geht es darum, dass man halt für Dicts
vielleicht auch die Plus und Minus als Operatoren haben möchte,
sodass man halt sagen kann, irgendwie Dict A plus Dict B.
Und dann werden sozusagen die Keys hinzugefügt
oder halt wird das eine,
werden halt die Keys, die in dem einen Ding drin sind, entfernt,
wenn man das halt abzieht.
Und das ist natürlich auch eine ganz,
Also es ist eigentlich relativ naheliegend.
Es wundert mich, dass da bisher noch niemand drauf gekommen ist,
dass man das irgendwie mal machen könnte.
Aber das ist auf jeden Fall eine ganz interessante Idee.
Und Guido hat da einen Artikel zugeschrieben.
Ja genau, der hat zweimal den Key irgendwie draus zugewiesen
und dann quasi einen Dictionary mit zwei identischen Keys erzeugt,
wo dann nur einer von überlebt hat.
Ja.
Irgendwie so.
Also wenn man halt, ich glaube, welcher Post war das?
Wo er A einmal die Nullen, A einmal die Eins zugewiesen hat
und dann war eins
übrig, weil das die letzte Zuweisung war.
Weil ich das richtig verstanden habe.
Genau, das war das Verhalten, was mich irgendwie
gewundert hat, aber das ist generell
so, das war schon immer so, offenbar,
wenn man halt, also insofern
ist es halt kompatibel mit diesem Verhalten,
dass wenn man
jetzt irgendwie ein Key mehrfach in einem Dikt hat,
dass dann halt immer das letzte genommen wird.
Und das war mir auch gar nicht klar,
dass das so ist, aber...
Also kein Duplicate Value oder Key Error oder sowas?
nein, nein, es wird einfach das Letzte genommen.
Und da hat er halt dazu, oder auf der Mail-Industrie geschrieben,
dass, ja, er hat damals lange drüber nachgedacht,
weil irgendjemand die Frage gestellt hat,
ob das Absicht wäre oder nicht.
Er meinte so, ich habe damals lange drüber nachgedacht
und es ist Absicht.
Ich erinnere mich an ein Programm, wo ich das dachte,
wo ich irgendwie einen komischen Fehler hatte,
und das, glaube ich, genau daran gelegen hat.
Weil, ja, irgendwelche Duplikate dann zwar drin waren,
ich das aber nicht gemerkt habe, erst irgendwann später,
als mir um die Ohren flog.
Ja, aber Guido hatte auch noch einen Blogpost dazu geschrieben, wo er überlegt hat, ob das mit diesen Operatoren halt eine gute Idee ist oder nicht.
Siehst du, wie diese Code Active State heißen, Ideas?
Ja, in seinem Blog war das Ding drin.
Und ja, da macht er tatsächlich den Punkt, dass das halt schon eine gute Idee ist.
hat da so das als Beispiel
quasi, wenn man jetzt mathematische, also
arithmetische Geschichten halt nicht
als Operatoren hätte, sondern
wenn man das mit Funktionen ausschreiben würde,
dann wird es halt sehr viel unklarer,
was eigentlich gemeint ist, jedenfalls wenn das
irgendwie komplizierter wird, weil man dann halt immer
erst die Funktion
mit den Klammern auflösen muss,
bevor man sieht, was passiert und während man
quasi, wenn man das als Operatoren
hinschreibt, hat man so eine Art visuelles Pattern-Matching
direkt schon, dass einem sagt, was
da passiert und daher sind für so
arithmetische Geschichten, um zu sehen, was da
passiert, ist es halt viel
sinnvoller, das mit Operatorenschreibweise
hinzuschreiben als mit Funktionen,
was man ja auch tun könnte.
Und für Dicts ist
halt die Frage, ob das Sinn macht, aber
also immer dann, wenn einem das dabei beim
Verständnis hilft, wenn man das anders hinschreiben
kann, dann kann es natürlich schon gut sein,
dass das irgendwie sinnvoll ist.
Und ja, das ist auf jeden Fall
glaube ich hier ein starkes Argument,
dafür und mal sehen.
Ich bin mir nicht sicher, ob wir das in Python 3.8
dann schon direkt sehen werden, aber es wäre auf jeden Fall
irgendwie eine interessante Idee
und ja, ich bin mal gespannt, wie das sich so weiterentwickelt.
Okay, okay.
Ja, noch eine
kleine News hatten wir, glaube ich, und das war der
Django Chat Podcast.
Genau, ja, es kommen ab und zu
neue Podcasts dazu und jetzt
fand ich besonders interessant
eben auch Django, ein Podcast,
der sich nur Django widmet, da
einer der beiden ist irgendwie einer der beiden
Django Fellows, die halt quasi sich, also
dafür auch bezahlt werden, da tatsächlich
an Django zu arbeiten und so die ganzen
Sachen zu machen, die halt normalerweise niemand tut, wenn er
nicht dafür bezahlt wird, halt irgendwie
zum Issue-Tracker kümmern
und
Releases machen und so.
Ja, und
das war schon, die ersten beiden
Episoden sind erschienen, die
erste war irgendwie relativ interessant.
Ich fand, das war auch so, dass da irgendwie eine ganze
Menge Überschneidung war zu dem, was wir in unserer
Django-Folge irgendwie erzählt haben, so von dem
so Rundtenor.
Ich seh grad, ich hab den auch gehört, ich bin begeistert.
Ja. Und eine Folge.
Gefällt mir sehr gut, also es ist
wirklich toll. Jetzt kam noch eine zweite Folge, die war
so eine kurze Folge dazu. Fünf Minuten.
Könnt ihr mal sehen, wie man in der
Kürze die Würze finden kann. Ja.
Weil sie halt irgendwie mal
ein Release von Django kaputt gemacht haben.
Ja. Und
ich bin mal gespannt, wie sich das so weiterentwickelt.
Das ist auf jeden Fall eine sehr empfehlenswerte
Geschichte. Dann gab's noch einen anderen
Pouted Patent Out Loud, aber da müssen wir nochmal gucken, also den fand ich
jetzt gar nicht so interessant
am Anfang. Ja, falls ihr noch einen Podcast
kennt, den wir noch nicht kennen, dann schickt ihn uns,
wir sind neugierig natürlich.
Ja, ich würde sagen, am Ende stellen wir nochmal so ein bisschen die
Pics der Woche, der Woche, des
Monats vor, aber wir sind glaube ich mittlerweile
so weit, dass wir so ein bisschen jetzt was über Pandas
erzählen können. Ja, Pandas, was ist das denn
überhaupt? Also beim Eishockey, ich bin ja
Eishockey-Finder, haben die Schiedsrichter jetzt so ein Pandasymbol
gehabt auf den Trikots, weil die eine
Kooperation mit dem WWF haben und dann
waren sie am Ende ein bisschen enttäuscht, dass der WWF da so eine Spendenaffäre
hatte. Aber ja, es ist manchmal so,
aber Pandas und Spendenaffäre hat wahrscheinlich jetzt bei uns
so viel nicht miteinander zu tun.
Nee, aber der Name bietet
natürlich schon so ein bisschen Verwechslungspotenzial.
Wir hatten da auch genau darüber
gesprochen haben, ob wir nicht irgendwie mal zusammen
eine Podcast-Episode machen wollen.
Hatte Simon auch irgendwie zuerst was anderes verstanden,
glaube ich. Ja, genau. Also es gibt
nicht nur Python Pandas
das Data Frame Framework,
sondern auch Python Pandas
3D, die Game Engine.
Ah. Und weil
ich ja irgendwie beide Themen abdecke,
war das, was ich gerade zuletzt
gemacht hatte, das Erste, was im Kopf wieder
aufgetaucht ist und das war die Game Engine und
dann haben wir, weiß nicht, fünf Minuten aneinander
vorbeigeredet. Wir können doch jetzt gerne noch mal
fünf Minuten über die Game Engine, Pandas 3D reden, wenn du magst.
Ist die in Python? Also
ich glaube, Game-Entwicklung
in Python ist vielleicht
eine Folge, zu der ich nochmal wiederkommen sollte.
Oh ja. Einfach, weil das sehr,
sehr umfangreich ist. Und es geht?
Es gibt es im Wesentlichen irgendwie
Pygame und Pandas als die beiden
großen etablierten, dann gibt es noch
so ein paar kleinere. Und damit kann man wirklich auch
Spiele machen, die auch gehen und die auch aussehen
oder sowas? Oder braucht man dafür noch Qt oder
sowas? Ich sage es mal vorsichtig, ja, damit kann man
Spiele machen, mit Pygame
2D-Spiele, mit Pandas 3D sogar
3D-Spiele. Was man
damit sehr gut machen kann, ist zu lernen,
wie so eine Game Engine wirklich funktioniert.
Ich glaube
aber nicht, dass man Triple-A-Titel
darin machen möchte, weil es dann doch irgendwann
umständlicher ist, als
eine von den großen 3D-Game-Engines,
die so am Markt sind,
die vielleicht auch ein bisschen mehr
klickbar sind, zu verwenden.
Ich muss überlegen, welche das waren. Das war Unreal,
Unity und
CryEngine.
Ja, okay, dann CryEngine ist ja nicht
frei. It 7 oder so 8.
Weiß ich gerade gar nicht.
Ich glaube, wir sind gerade völlig off-topic.
Wir wollten über Pandas sprechen. Genau, also Pandas 3D
ist die Game-Engine, darüber sprechen wir heute dann
nicht. Und Pandas
ist im Wesentlichen
eins der Python-Tools,
an denen man nicht vorbeikommt, wenn man Datenanalyse
betreibt. Okay, wir sind
wieder mal bei der Datenanalyse.
Datenbanken hatten wir übrigens in der letzten Folge,
für alle, die sich das noch nicht angehört haben, eine ziemliche Mammut-Folge
mit, wie lange, drei Stunden haben wir
gebraucht? Ja, ein bisschen mehr, aber
genau um den Dreh. Wenn ihr mal wieder die Wohnung
richtig putzen wollt, dann was soll ich, die Ohren?
Ja,
an der Stelle würde ich ganz gerne noch kurz
meinen Hintergrund in der Datenanalyse
erwähnen, damit man so ein bisschen einordnen kann,
aus welcher Richtung meine Kommentare
kommen. Als
Biologe war damals
Perl die große
Programmiersprache, um alles zu lösen.
Und erst zum Ende
meiner Forschungszeit hat sich dann irgendwann
Python durchgesetzt. Das heißt, ich habe noch sehr
viel in Perl gemacht. Und
was man in Perl gar nicht gut
konnte, zumindest ich konnte das nicht, ist
Daten nachher analysieren
und visualisieren. Aber die
Aufbereitung war da sehr gut. Das heißt,
für die Analyse und die
Visualisierung sind wir dann immer zu R
rüber gewechselt. R ist
auch eine Programmiersprache,
ist eine eher mathematische
Annotation zur
Datenanalyse.
Und wenn ich so
die Branche, sage ich mal, richtig
überblicke, dann wird am meisten
R und Python
benutzt und vielleicht dann noch
MATLAB als
dritte Alternative,
wenn Leute heute Datenanalyse machen.
Was meinst du denn
mit Datenbereinigung?
In der Biologie ist das so,
dass die Daten immer unheimlich fuzzy sind.
Also man hat nie ganz konkrete Messwerte,
sondern man hat immer super viele Abweichungen,
mal Fehlmessungen, mal Werte, die man gar nicht erheben konnte.
Du musst dich dann entscheiden,
ob du eine Rundung anwendest oder nicht.
Vieles davon führt dann erst mal dazu,
dass die Daten nicht mehr so strukturiert sind,
wie man das eigentlich dachte in der Tabelle.
Das kommt auf die Messinstrumente im Wesentlichen an.
Das heißt, die erste Aufbereitung ist erstmal,
die Daten in ein maschinenlesbares Format zu bringen.
Und da ist es von unfassbarem Wert, wenn man programmieren kann.
Dann muss man jede einzelne Zeile oder Zelle durchgehen
und die manuell korrigieren.
Genau, also ich habe auch tatsächlich schon Kollegen damals gesehen,
die von Programmierung gar keine Ahnung hatten,
die dann angefangen haben, in Excel sich das händisch zusammenzustellen
Und dann haben wir uns kurz zusammengesetzt, ein Makro geschrieben und dann ging das irgendwie doch schneller. Und fehlerfreier an der Stelle auch. Und dieser erste Schritt, überhaupt die Daten erstmal maschinenlesbar zu kriegen, der ist im Wesentlichen unabhängig von der Analyse, aber notwendig.
Und nochmal für unsere ganz Anfängerhörer, was denn überhaupt maschinenlesbar bedeutet?
Ich habe da mal irgendwann ein Beispiel vorbereitet für Mediziner, die von Excel zu R wechseln wollten.
Und das Beispiel war eine Tabelle, eine Excel-Tabelle aus meinem Laboralltag,
wo dann in einem Tabellenblatt an mehreren verschiedenen Stellen so kleine Subtabellen zu sehen waren,
wo die Messdaten drin standen.
Da gab es dann quasi einmal Experiment A war so ein 5x4-Raster,
Experiment B war so ein 5x4-Raster, was irgendwie rechts daneben stand.
Und dann gab es noch ein Experiment C, was dann mittig darunter stand,
auch 5x4-Raster.
Das ist für den Menschen super lesbar,
weil man kann sofort die Blöcke identifizieren
und sich die Messdaten angucken.
Für eine Maschine ist das aber nicht mehr strukturiert lesbar,
weil die Koordinaten nicht klar sind.
Und was häufig passiert ist, wenn Menschen Tabellen ausfüllen, um die visuell ansprechend zu machen, verletzen die ein wichtiges Kriterium, dass in jeder Zeile oder Spalte, je nachdem, woran man sich orientieren möchte, nur ein Datensatz wirklich drinsteht.
Oder stehen sollte, weil da unterschiedliche Informationen sind, die nicht voneinander getrennt sind. Dann stehen zum Beispiel sowas wie eine Spalte, wo zwei verschiedene Datensachen auf einmal drin stehen. Einmal Temperatur in Celsius, einmal in Fahrenheit oder sowas. Oder ist das legitim?
Das könnte ja noch zusammenpassen, aber einmal die Temperaturen in Celsius und Fahrenheit für das eine Experiment und dann das Ganze nochmal für das andere Experiment irgendwo weiter hinten in der gleichen Zeile, aber nicht klar strukturiert abgrenzbar.
Ja, also das ist halt quasi bei Datenmarken die erste Normalform, dass man in der Spalte immer nur einen Wert stehen hat und nicht mehrere zum Beispiel, was halt dann manche Leute tun.
Also Fahnenheit und Zeltes wäre okay, wenn man die Information enthalten wäre in der Zelle, ob es Zeltes oder Fahnenheit wäre.
Weil das wäre sonst problematisch.
Ja, also wir kommen da sicherlich gleich nochmal zu, so gut das geht, in einem Podcast Tabellen zu beschreiben.
Grundsätzlich, wenn man so eine Tabelle hat, wo man Zeilenbeschriftungen hat und Spaltenbeschriftungen hat und die ganze Tabelle ist rechteckig,
dann kriegt man die auch sinnvoll maschinenlesbar ausgewertet.
Also Probleme fangen dann an, wenn man keine zweidimensionalen Tabellen mehr hat,
keine, die man mal eben so auf seinen Whiteboard malen kann,
welche, die man bauen müsste oder wo man irgendwelche Dimensionen verbraucht,
die wir uns jetzt nicht so räumlich vorstellen können.
Oder wo tatsächlich Lücken drin sind und die Muster für Menschen zwar noch erkennbar bleiben,
aber für eine Maschine die Koordinaten dann zum Beispiel nicht mehr zusammenpassen.
Okay.
Ja, okay, das haben wir so ungefähr verstanden, was so maschinenlesbar dann bedeutet für die einzelnen Daten. Und wo kommt jetzt Pandas dann ins Spiel?
Ich habe mal, ich glaube, das war Python User Group Treffen oder irgendwie sowas in der Richtung, habe ich mal eine Folie gesehen in einem Vortrag. Ich habe die leider nie wiedergefunden. Da fand ich das ganz schön beschrieben. Da waren irgendwie so Python-Module konzentrisch angeordnet und im innersten Kreis war NumPy oder NumPy, SciPy und Matplotlib für die Darstellung von Vektoren.
NumPy und für
einfache statistische Analysen
SciPy und für Visualisierung
Matplotlib. Und dann war
der Kreis eins weiter draußen
so ein bisschen das, was darauf aufbaut.
Das war dann Pandas,
das war
Statsmodels, war das
glaube ich. Also für Zeitreihen
und so. Genau. Und
Seaborn. Und das waren dann die
Pendants. Also Seaborn auch
wieder zur Visualisierung und Statsmodels
im Prinzip zur statistischen
Auswertung und Pandas eben zum
Data Handling, aber
jenseits von einfachen Vektoren.
Aha, okay.
So, und da kommen wir im Prinzip auch schon wieder in den Bereich,
wo man immer den Vergleich zwischen Excel normalerweise
führt, wenn man das mit Leuten
bespricht, mit denen man zusammenarbeitet,
weil Excel kennt irgendwie jeder. Also
Tabellenkalkulation ist jedem sofort
ein Begriff und alle wissen auch sofort,
okay, es gibt Zeilen und Spalten.
Das ist so, dass das
bare minimum, was man wissen muss, um
mit Pandas was anfangen zu können.
Das hat man wahrscheinlich in der Schule schon mal aufgemacht oder so,
oder aufmachen müssen. In der Regel schon, ja.
Genau, das heißt, bei Pandas
sind wir jetzt in dem Bereich von
Data Handling.
Also, wie kann ich meine Daten
laden, verarbeiten,
zur Verfügung stellen für
Analysen. Und wie
macht Pandas das?
Gibt es da Spezies?
Also ich würde sagen, also das ist auch das
denke ich
Hauptfeature von Pandas ist, dass
man damit die Daten überhaupt erstmal irgendwie
in so ein
ja,
reinbekommt irgendwie. Also
Westman Kinney hat das auch mal gesagt, dass die
populärste und wichtigste Methode, die
Pandas halt hat, ist halt Read CSV,
die sehr, sehr
flexibel ist und man kann irgendwie so ungefähr
jedes CSV, was irgendwo, ein CSV ist
ein sehr hässliches Format und
Leute machen unglaubliche und unheilige
Dinge damit, aber
man kann irgendwie mit dieser
Funktion kann man das fast alles parsen.
Die hat sehr viele
Argumente und sehr viele Dinge, an denen man da irgendwie
was drehen kann und man kriegt fast alles damit geparsed
und
das heißt, egal wie komisch die Daten aussehen,
die man so hat, man kriegt sie irgendwie
mit Readsys wie oft irgendwie
in Pandas rein und hat sie dann halt in einem
sauberen Format und kann das dann halt wieder in anderen Formaten
rausschreiben. Aber gut, Pandas kann nicht nur
CSV lesen, sondern halt auch diverse andere
Formate
von JSON
über, keine Ahnung, XML oder was auch immer.
Teilweise werden dann halt andere
Bibliotheken unten drunter verwendet, um das halt einzulesen.
Aber
das ist halt,
also Pandas ist eigentlich immer so der erste
Schritt, wenn man irgendwo Daten herbekommt,
um die halt in
ein Format zu bringen, mit dem man irgendwas machen kann, um es halt
irgendwie einzulesen in Programmen,
da nimmt man halt eigentlich immer Pandas, weil das halt
Pandas hat so vorbereitete Funktionen für, weiß nicht,
eine Zeitreihenanalyse oder sowas.
Nein, nein, der Analyseteil ist nochmal ein bisschen,
also ja, Pandas kommt auch daher,
also das ist mal
entwickelt worden, Westman Kenny hat das
gestartet, das Projekt 2008, als er bei
RQ Capital, glaube ich, irgendwie so ein
Hedgefonds-Investment-Dings
da gearbeitet hat und
da ging es um
Zeitreihen und
tatsächlich ist bei Pandas immer noch so
der Hauptfokus, oder es ist halt das, was
Pandas auch besonders gut kann, sind halt so Zeitreihen-Geschichten.
Aber man kann auch diverse andere Dinge damit machen.
ja,
da gab es halt noch nichts
in Python. Die Leute haben
damals Excel verwendet oder halt
irgendwie kommerzielle Software
und ja,
da wurde halt
dann ist halt dieses Projekt gestartet.
Und so ein bisschen, auch heute ist es halt noch so, dass viel Geld geht halt so in Deep-Learning-Geschichten, also wenn man sich anguckt, wie viel Geld wird halt eigentlich ausgegeben für Open-Source-Entwicklungen, ist sowieso irgendwie relativ erschreckend, wie wenig Ressourcen sozusagen Open-Source-Projekte haben und wie viele Leute dann und wie viele Firmen im Grunde darauf angewiesen sind, weil wenn man dann anguckt, was Firmen machen, auch große Firmen, dann ist das ja doch im Endeffekt machen die halt ganz viel mit so freier Infrastruktur, Software, die halt irgendwie auch alle Leute kennen und so.
Aber die wird wenig, bekommt eigentlich wenig Ressourcen, da gibt es wenig Geld, da gibt es wenig Leute, die überhaupt beruflich daran arbeiten.
Und die Projekte, die am meisten Geld bekommen, sind sowas wie TensorFlow oder so, weil man drüber schreiten kann, inwiefern das halt noch Open Source ist.
Und auch die ganzen Cloud-Dienste oder so, die haben alle irgendwie Methoden, Daten da reinzubekommen, Daten wieder rauszubekommen.
bekommen und auch in denen steckt
relativ viel Geld drin, aber
diese Sachen sind alle
ziemlich schlecht irgendwie
und Pandas füllte halt so eine Lücke.
Ist halt eigentlich ultra wichtig, weil
irgendwie diese ganzen Datenimport-Export-
Geschichten sind halt etwas, was man immer braucht
und irgendwie es gibt
außer Pandas gibt es keine
Projekte, die das irgendwie ordentlich gemacht haben
und du kannst natürlich irgendwie deine
tolle Deep Learning TensorFlow-Geschichte nehmen
irgendwie, aber wenn du die Daten halt nicht
hast, um damit irgendwas machen zu können,
dann hilft dir das alles nichts
und ja, das
ja, eben Westman Kenny erzählt
davon halt auch immer, dass ihn das total wundert
und dass er das total seltsam findet, dass halt so ein wichtiger
Teil der Infrastruktur so wenig
Liebe erfährt quasi
und
dass seine Hauptmotivation war
zu sagen, okay, da muss man mal was tun
das muss doch irgendwie, dieses Problem muss man
doch lösen, das ist halt irgendwie ein Problem, was alle haben
und was irgendwie sehr ärgerlich ist und
ja
Ja, und das ist halt, das macht Pandas auch sehr gut irgendwie. Und das ist immer so ein erster Schritt, wenn man irgendwie Daten, auch wenn man jetzt hinterher Machine Learning machen möchte oder so, hat man trotzdem immer Pandas mit dabei, weil man die Daten ja erstmal irgendwie in ein Format bringen muss vorher und vielleicht aufräumen muss, sauber machen muss.
Da gibt es auch immer so einen schönen Spruch, irgendwie Data Science ist halt so, oder auch Machine Learning ist halt, 80% ist halt Data Cleaning und 20% ist sich darüber beschweren, dass irgendwie 80% Data Cleaning sind.
Ja, das trifft es sehr gut. Ja, ich meine, die andere Sache ist, als Mensch möchte man ja auch sich die Daten vielleicht zwischendurch mal angucken können. Und dafür braucht man irgendwie eine Datenstruktur, in der man sehr schnell zu Rahmendaten kommt.
Vielleicht braucht man mal einen Mittelwert oder will sich mal die Verteilung angucken, gruppiert bei irgendwelchen Kategorien oder sowas. Also sicherlich ist diese Import-Geschichte von Pandas eine der mächtigsten, die ich bisher gesehen habe, was auch so fehlende Datenpunkte angeht und wenn die Struktur mal nicht ganz stimmt und man kann einzelne Zeilen überspringen, wenn da mal was kaputt geht oder sowas.
Da habe ich jetzt übrigens direkt eine doofe Frage zu, weil es gibt ja irgendwie bei Pandas so ein paar Werte, die, wenn die halt nicht da sind, die man irgendwie füllen kann. Da gibt es ja irgendwie jetzt aber so drei Typen. So Null und None und None. Warum, wieso braucht man da drei?
In Pandas? Also ich wüsste jetzt
eigentlich nur, dass es da Not-a-Number gibt.
Ja. Und das ist
historisch sozusagen der
hier ist kein Wert
von NumPy.
Das ist auch irgendwie sozusagen ganz
unten drunter ist das
tatsächlich ein
in Float kann man das halt ausdrücken und
ja, das hat halt auch so die
leichten, das leichte Problem, dass
man im Grunde immer dann, wenn man solche Werte hat, dann
halt auch der Datentyp irgendwie
Float sein muss, was so ein bisschen doof ist.
Bis vor ganz kurzem war das noch so,
dass man halt, wenn man jetzt eine Integer-Spalte hatte
und da fehlt halt jetzt ein Wert,
und man hat halt gesagt, okay,
da kommt irgendwie was dazu, was halt irgendwie fehlt oder so,
und man macht einen Re-Index und guckt,
und dann hat sich plötzlich der Typ der Spalte in Float geändert,
weil es halt keine fehlenden Werte in Integer-Typ-Typ-Spalten gibt.
Und das ist ein ziemlich blödes Problem.
Aber jetzt gibt es halt irgendwie seit einiger Zeit diese Array Extensions, Array Extensions API für Pandas und die halt mit Cyber Pandas dazugekommen ist.
Ich weiß gar nicht, welche Version das genau war. Und jetzt hat auch Ende Januar ist die letzte größere Release von Pandas erschienen. Ich glaube 0.244 oder so.
0.244, ja.
Und da ist jetzt halt auch ein natives Integer-Spaltenformat drin, das halt auch nannen kann.
Und das ist natürlich total cool irgendwie.
Und dadurch, dass man jetzt quasi nicht mehr NumPy unten drunter liegen hat, kann man da auch diverse andere coole Datentypen irgendwie verwenden, die vorher so nicht möglich waren, weil man ja immer auf NumPy angewiesen war.
Also NumPy ist auch ganz cool, aber NumPy hat halt das Problem, dass das grundlegende Design dafür ist halt jetzt doch schon wahrscheinlich fast 20 Jahre alt und passt halt auch nicht mehr so richtig auf die Anforderungen von heute und dummerweise hat Panas aber viele der Implementationsdetails in NumPy halt rausgelegt und das kann man jetzt auch nicht mehr so einfach ändern, weil das halt schon, also wenn man das wieder ändern würde, würde das Code brechen und dann wäre keine abwärtskompatiblen Änderungen mehr.
Und das ist natürlich alles so ein bisschen eine blöde Situation.
Aber
irgendwie mit dieser Array-Extension-API hat man
auf jeden Fall eine Möglichkeit, wenn man den Typ ändert, dann
ist das alles eigentlich in Ordnung.
Und dann kann man da auch schöne neue Sachen machen,
ohne dass man auf NumPy irgendwie angewiesen ist.
Zum Beispiel was halt,
also es sind so Beschränkungen, die sind echt blöd.
Also wenn man auf NumPy
unten drunter basierendes
Pandas hat, dann hat man halt
sowas nicht wie zum Beispiel
Decimal-Types.
Also einmal man hat keine fehlenden, keine
Missing-Value-Support für sowas wie
Integer, was auch schon schlimm ist, aber man hat halt
auch, wenn man jetzt mit Geld zu tun hat,
was man ja vielleicht auch irgendwie,
dann hat man halt bloß Float,
das will man auch nicht. Also man
würde das dann irgendwie wahrscheinlich eher
Geld in Integer, also in Cent-Integer
oder sowas verwenden.
Viele werden wahrscheinlich irgendwie Float
nehmen, so,
und dann denken, ach, das wird schon irgendwie hinhauen
und dann böse Überraschungen überleben,
weil das funktioniert halt
überhaupt gar nicht. Und man
kriegt diverse richtig böse Probleme, wenn man das
macht. Und in Datenbanken
ist das Problem eigentlich auch schon lange gelöst.
Da gibt es den Decimal-Type
genau für sowas, der dann
halt auch ordentlich
rundet und so. Und
in Python gibt es auch einen nativen
Decimal-Type. Der ist blöderweise
nur total super langsam. Also den kann man eigentlich auch
nicht nehmen.
Und jetzt gibt es halt
sozusagen als Array-Extension
Type halt auch Decimal,
sodass man das halt auch in Pandas Data
Frames halt Geld quasi mit Kommastellen
verwenden kann, ohne dass es da irgendwie,
ohne dass man da mit schlimmen
Konsequenzen rechnen muss.
Und es gibt sowas wie
DateTime mit Timezonen
dran und so, das ging vorher auch nicht.
Und das ist... Achso, sowas wie
Grad mit Celsius-Erfahrenheit vielleicht.
Das ist nochmal ein anderes, genau,
das möchte man auch gerne haben.
Ich weiß nicht, ich glaube, das ist nicht direkt in Pandas drin.
Es gibt Bibliotheken dafür, dass man halt
an Spalten auch noch irgendwie so eine
Maßeinheit dran klebt.
Die Annotationen
und auch Skalierungsfaktoren
kommen auch mit unter aus dem
zugrunde liegenden Datenformat, aus dem man nachher
importiert. Also es gibt irgendwie
wissenschaftliche Datenformate, die speichern sowas
alles mit. HDF5
oder NetCDF oder
wie das inzwischen heißt. Wie sieht das dann aus?
Ist da eine Spalte, ein Tupel drin?
Da gibt es im Prinzip
irgendwie so eine Tabelle von
Metadaten, wo drin steht,
welche Spalten, welche Maßeinheit, welches
Skalierungsfaktoren haben, wann die zuletzt
bearbeitet wurden. Und darunter
stehen dann serialisiert die Daten drin.
Und dadurch hat man
sehr, sehr schnellen, sequentiellen
Zugriff auf seine Daten, hat aber
trotzdem die Möglichkeit, diese
Skalierung und Einheiten
mitzuführen. Und
in Pandas weiß ich nicht, ob das
inzwischen mit importiert wird,
aber
diese Erweiterung.
Ja, ich habe jetzt
normalerweise auch nicht mehr parat, wie die
Bibliothek, es gibt eine Bibliothek für so Maßeinheiten und so was.
Ich weiß aber nicht genau, wie das
gemacht ist, müsste ich nochmal nachgucken.
Vielleicht können wir das einfach dann
beim nächsten Mal nachreichen oder so.
Auf jeden Fall, da gibt es etwas
und das kriegt man schon irgendwie
alles auch mit dazu geschrieben.
Ja, also genau, das
eigentlich, so wie früher, oder
der Default ist immer noch bei Pandas,
wie Sachen gespeichert werden, das
nennt sich irgendwie Block Manager oder Block Storage
und das sind immer
2D NumPy Arrays
und
die sind halt immer sozusagen, also man
würde eigentlich denken, dass
ein DataFrame, dass jede Spalte
irgendwie ein
eindimensionales NumPy Array
ist, aber das ist halt nicht so,
sondern ein DataFrame besteht
aus Blocks
von 2D
NumPy-Arrays jeweils
zu einem, also unterteilt
nach Datentyp, also wenn ich jetzt sagen habe
ein
DataFrame, der drei Spalten
hat, zwei davon float, einer
Integer, dann besteht das
Ding aus zwei NumPy-Arrays, eins
mit Integer und eins mit float,
das halt zwei Spalten hat.
Da muss man jetzt natürlich aufpassen, von welcher
Seite man drauf guckt, weil
aus Pandas Sicht ist das erstmal
eine Liste von Pandas Series,
Da haben wir auch noch nicht drüber gesprochen, was das ist.
Die Abbildung als
NumPy-Arrays ist natürlich
dann irgendwie die technische zugrunde
liegende Abbildung.
Ja, genau. Das ist halt,
eigentlich sollte das egal sein.
Sollte man sich eigentlich keine Gedanken darüber machen,
sondern, genau, eigentlich ist eine Series halt quasi,
kann man es verstehen als Spalte oder eben Vektor,
eindimensionale
Datenstruktur mit halt vielleicht noch einem Index dran.
Aber
so wird es halt nicht gespeichert und
das Blöde ist, dass diese
Abstraktion halt auch so liegt, weil
wenn man jetzt
zum Beispiel eine Spalte hinzufügt zu einem DataFrame,
dann hat man das Problem,
dass dadurch,
dass jetzt, wenn man schon ein paar
Float-Spalten da drin hat und man
fügt jetzt eine dazu, dann
geht das ja nicht mehr wirklich,
sondern dann müssen die kompletten Daten alle
kopiert werden dafür.
Und wenn man jetzt in der Schleife
irgendwie Spalten hinzufügt oder so, dann
kann es sein, dass einem der Speicher platzt und man weiß überhaupt
nicht warum. Das heißt, man muss im Grunde wissen,
dass Pandas das so macht
und dann gibt es dann immer so Tipps,
die dann sagen, wenn man da irgendwie viele
Spalten hinzufügt, dann immer erst mal die einzelnen
Spalten sammeln und dann hinterher alle
zusammenfügen oder so, nicht
irgendwie auf einem großen Data-Frame eine Spalte hinzufügen,
dann noch eine hinzufügen, das ist schlecht
und das sollte eigentlich natürlich,
das sind so Schwächen bei Pandas, das sollte ja eigentlich
nicht, das sollte einen gar nicht interessieren, wenn man das
benutzt. Dummerweise muss man solche
Sachen aber dann vielleicht doch wissen, weil
man halt dieses Problem da an der Stelle
noch hat. Aber das kann sein, dass das jetzt
alles demnächst besser wird oder das ist jetzt
mit der letzten Version ist es halt schon ein Stück
besser geworden und da sind halt
die einzelnen Spalten haben ihren eigenen Typ und ihre
eigene Speichergeschichte und dann ist das alles
nicht mehr so ein Problem.
Aber ja, das ist vielleicht auch noch interessant.
Also Pandas ist gedacht für so Daten,
also Small Data kann man
quasi sagen, also
Daten im Bereich von so ein paar
Gigabyte, also einstellig Gigabyte,
weil halt da fast
alle Operationen dazu führen, dass das irgendwie kopiert wird,
kann es sehr schnell sein, dass man halt
irgendwie auch, dass man halt 5 oder
vielleicht sogar bis zu 10-facher der
Datenmenge, die tatsächlich auf der Platte landet oder so,
man dann als Hauptspeicher braucht, weil
ja, man kopiert ein paar,
äh, man fügt ein paar Spalten hinzu, transformiert
ein bisschen was und dann schon hat man irgendwie einen 5-fachen Hauptspeicher
verbraucht.
Und daher ist es halt nicht so richtig effizient.
Kann auch sein, dass es jetzt dann halt besser wird.
Aber, äh, also für
größere Sachen kann man Pandas nicht so super
benutzen, aber
für diese kleinen
Datenmengen ist es halt sehr, sehr cool, weil es super
interaktiv ist und da auch viel Optimierung
reingesteckt wurde, die Operationen
halt auf so, auf den Datenmengen halt
schnell zu machen, sodass man halt
oft dann nicht ein paar Sekunden warten muss,
sondern eigentlich immer nur so ein paar hundert Millisekunden
und das,
gerade wenn man das jetzt zusammen mit
Jupyter Notebooks halt
interaktiv in einem Browser verwendet,
ist es halt sehr wichtig, dass man da nicht irgendwie, wenn man
irgendwas ausführt, halt lange warten muss, sondern
man drückt irgendwo drauf, es wird ausgeführt
und man sieht ein Ergebnis und
kann damit direkt weiterarbeiten.
Genau.
Ja, vielleicht noch mal kurz
in Jupyter Notebooks, also tolles Tool tatsächlich,
wenn man sich so gerade so Daten aus der
Wissenschaft angucken will, einfach ein
DataFrame laden, da die ganzen Daten reinkloppen
und dann mit Matplotlib und Seaborn
irgendwo direkt live immer
Änderungen verfolgen können. Ja, ich würde fast noch
sagen, also der ganz, ganz klassische
Workflow ist, man ruft einmal
Describe auf, dann kriegt man so einmal die
Rahmendaten, Streumaß und
Lagemaß auf dem Dataframe
und dann kriegt man direkt alle statistischen
Auswertungskennzahlen, die man so kennt.
Genau, .describe, Klammer auf Klammer zu,
fertig, dann kriegt man erstmal einen groben
Überblick über seine Daten. Dann kann man
natürlich auch in die Daten direkt reingucken mit
Head und Tail und
das ist in meiner Erfahrung auch das, was man
bei einem neuen Datensatz als allererstes
mal macht, um sich anzugucken, womit
arbeite ich denn überhaupt?
Und spannenderweise, wir waren eben bei Datenimport, da ist noch eine Sache, meine Lieblingsfunktion ist an der Stelle tatsächlich Import from Clipboard.
Also man kann tatsächlich, wenn man gerade irgendwie mal in Excel war oder in OpenOffice und was kopiert hat, das in Pandas DataFrames direkt wieder einladen.
Das habe ich allerdings noch nie ausprobiert in Jupyter Notebooks. Ich weiß nicht, ob der das hinkriegt, aber ich wüsste jetzt auch erstmal nicht, was dagegen sprechen sollte.
Nö, das kann gut sein, dass das funktioniert, ja.
Also kann man sich halt auch ganz kleine
Datenchunks, kleine Tabellen direkt
aus der Zwischenablage
in seinen Data-Frame reinladen.
Das heißt, wenn wir jetzt von diesem
Gigabyte-Bereich liegen, ich glaube, für wissenschaftliche
Anwendung müsste das in den meisten Fällen noch relativ
ausreichend sein. Ja, ja, absolut. Also das ist sowieso
so, die allermeisten Leute haben
nicht mehr Daten. Also für die allermeisten
Leute reicht es aus. Wenn man mehr
hat, dann weiß man das und dann kann man auch was anderes
nehmen.
Ja.
Ja, aber stimmt, wir hatten
eben noch gar nicht genau, vielleicht sollten wir da so ein bisschen
systematisch auch nochmal kurz reingehen, was
also Pandas,
genau, das hat auch was damit zu tun,
wo der Name herkommt, also Pandas steht
eigentlich für Panel Data oder
das war halt auch mal das, was halt so in der Finanzwelt
wo Leute von gerätet haben, von Panel Data
und damit meinen sie
dann halt oft Excel Sheets
irgendwie oder mehrere davon
und das kann Pandas auch, ist
aber irgendwie nicht mehr so, also es gibt auch noch
es gibt halt einmal Series, es gibt Data Frames
das ist halt sozusagen die zweidimensionale
Tabelle
irgendwie, Serious ist eindimensional
und dann gibt es auch noch Panels, die sind halt
dann mehrdimensional
und die werden aber eigentlich nicht mehr
verwendet, glaube ich, oder
wurden eigentlich nie so wirklich
viel verwendet und das ist, glaube ich,
überliegen die Leute auch gerade, ob sie das irgendwie wieder
rausnehmen, weil es eigentlich ziemlich sinnlos ist
und der Hauptnutzen irgendwie bei den Data Frames
ist.
Genau.
Daher kommt der Name.
Es ist ein bisschen blöd, wenn man danach googeln will
und dann hat man Tierbilder.
Aber wir haben immer wieder Tierbilder
dabei. Auch interessant, dass das Vorbild
für Pandas ist R,
denke ich mal.
Das ist mit Googeln auch nicht viel einfacher, aber
genau.
Ja, ich weiß nicht,
du hast auch schon mal mit A gearbeitet,
Simon.
Wie kann man
das eigentlich miteinander vergleichen?
Und es ist ja vielleicht auch ganz interessant zu sehen, wo das herkommt.
Ja, also ich habe in meiner Forschungszeit sehr viel zwischen R und Excel hin und her gewechselt.
Und tatsächlich muss ich sagen, die R-Data-Frames, die den Pandas-Data-Frames sehr, sehr ähnlich sind,
die hatten irgendwie so zwei, drei zentrale Vorteile gegenüber Excel, weswegen ich irgendwann komplett gewechselt bin.
Einer ist sicherlich, dass die Data-Frames immer rechteckig sind.
Also man kann nicht eine Spalte mit weniger Daten füllen als die nächste Spalte.
Es muss zu jeder Zeile immer für jede Spalte auch einen Wert geben.
Also es gibt für jeden Index irgendwie keinen Error.
Genau, wenn es ein Not a Number ist, ist das okay, aber es muss auf jeden Fall irgendeinen Eintrag geben.
Das führt dann dazu, dass man keine Überprüfung mehr machen muss, wie lang ist denn meine Spalte gerade, in der ich bin.
dann gibt es bei DataFrames grundsätzlich auch Typen je Spalte.
Das ist in Excel nicht so.
Da hat jede Zelle im Prinzip einen Typ, wenn man will.
Und da kann man auch ganz viel bösen Schabernack mit treiben.
Und in DataFrames, dadurch einfach, dass man eine Series pro Spalte hat,
hat auch eine Spalte immer nur einen Typ.
Und das Dritte, was ich an Data Frames unheimlich zu schätzen wusste, waren, in A heißen die Factors, in Pandas heißen, glaube ich, einfach nur Categories oder haben gar keinen speziellen Namen, dass, wenn man kategorische Daten hat, die erstmal als Text erscheinen, sowas wie, weiß ich nicht, Beispiele.
Blau, Rot, Gelb als Farben in einer Spalte.
Dass die in dem zugrunde liegenden Datenformat
erst mal sowas wie Integer sind
und entsprechend auch relativ schnell
zum Indizieren benutzt werden können,
aber für die Anzeige, für das Menschenlesbare
wieder als Rot, Gelb, Grün, Blau dargestellt werden.
Okay. Wie macht Pandas das? Als Dictionary dann?
Das war lange, also in Pandas heißen die Dinger Categorials und das wurde dann quasi intern irgendwie auf Integers abgebildet. Man hatte die einfach durchnummeriert und dann war das halt, was halt natürlich auch viel weniger Platz braucht als Text, aber jetzt auch glaube ich mit 0.24 ist es jetzt so, es hat auch einen eigenen Datentyp bekommen, sodass es halt jetzt auch so ein First Class Citizen im Grunde ist.
so vorher war es halt auch mal so, naja,
es sind komische Dinge passiert. Ich hatte zum Beispiel mal
irgendwann
mit Categoricals
auch so ein Problem. Ich habe da irgendwie
größere Data Frames irgendwie zusammengebastelt
und dann ist mir
irgendwie so regelmäßig der Hauptspeicher explodiert
und ich wusste nicht warum, habe ich dann auch einen Bug
irgendwie bei Panas gefeilt und
der war dann ziemlich lange offen.
Das hatte halt auch damit zu tun, dass es nicht
irgendwie nativ irgendwie da drin war,
sondern das war halt mit den anderen IntelliJer-Geschichten
irgendwie verknuselt und
Ja, das ist schrecklich.
Ja, aber genau, das ist natürlich eine sehr nette Sache,
wenn man das halt so machen kann.
Ja, das heißt, man sieht halt den Text in der Tabelle,
aber in Wirklichkeit speichert man halt viel weniger Daten,
halt nur eine Zahl.
Ja, praktisch.
Wie schaut man sich denn so Daten dann an?
Also ich musste ja irgendwie eine Struktur bringen.
Ich habe jetzt irgendwie ganz viele Spalten irgendwie mit Zeilen
in meinem großen rechteckigen Datenfeld
drin oder sowas und ich möchte jetzt irgendwie
die kombinieren.
Also man kann auch direkt auf dem,
also das benutze ich tatsächlich ziemlich gerne,
man kann sagen,
also DataFrame, man kürzt es normalerweise immer ab
mit df, also das
Standardobjekt, was man dann halt sozusagen hat,
heißt einfach df
und da kann man einfach sagen df.plot
und dem halt noch so ein bisschen Parameter
mitgeben und dann
plottet das halt direkt.
Dann kannst du ja dann Daten anzeigen,
die du dann reingegeben hast, also
die Visualisierungsebene dann damit quasi.
Genau, genau. Und im Notebook sieht man halt auch dann direkt irgendwie
quasi grafisch was.
Standardmäßig ist es dann halt ein Matplotlib,
aber man kann halt das auch,
dieses Plotting-Backend von Panda
sozusagen austauschen, also es ist halt so pluggable und man kann
das austauschen und man kann halt auch Bokeh
zum Beispiel nehmen oder
weiß gar nicht, ist auch noch viel
andere. Ich habe Plotly
schon gesehen in dem Zusammenhang
und Seaborn ist ja im Prinzip
Matplotlib nochmal ein bisschen erweitert
kann man da auch reinpluggen.
Genau, so dass es halt, man hat halt
immer, kann es dann anders aussehen
lassen, so dass zum Beispiel bei Bokeh oder
Plotly ist es halt so, wenn man dann sagt
DF Plot irgendwas, dann kann man
das, dann ist das, was man sieht,
dann halt auch scrollbar zum Beispiel,
man kann da drin zoomen oder so,
was man bei einem Matplotlib-Bild jetzt nicht machen kann,
weil da ist einfach, das ist quasi dann halt so ein
statisch rausgerendertes PNG oder so
und dann, wenn man da reinzoomt,
wird es nur pixelig, aber man sieht
nicht mehr, während halt bei
eben dieser, bei Plotly
oder so hat man dann, kann man, wenn man
reinsucht, sieht man einfach an der Stelle mehr
und das, man muss
an dem Plotaufruf eigentlich
nichts ändern, sondern man tauscht einfach nur das
Backend aus und
ja, das ist schon sehr nett und das verwende ich tatsächlich
oft irgendwie
um Sachen zu visualisieren.
Wenn man so einmal kurz schnell so einen Überblick bekommt.
Wie suche ich mir die Daten denn aus? Also wie kopiere ich
denn da irgendwas von den Daten, wenn ich ja so ganz viele
Spalten und Teilen habe? Also wenn
man gar nicht weiß, wie man anfangen soll,
wenn ich mich richtig erinnere,
macht Plot standardmäßig einfach ein
Pair-Plot. Alles gegen alles.
Dann sieht man schon mal, wie sind die Daten zueinander
verteilt. Dann kann
man Effekte sehen, wie
auf zwei bestimmten Variablen
ist die Verteilung eher so bimodal.
Man hat zwei Felder von Punkten oder sowas.
Also da kann man schon grundsätzlich
mal sehen, wie sind meine Daten überhaupt verteilt.
Ansonsten
gibt es ja oft eine Fragestellung.
ideellen Welt gibt es im Vorfeld
eine Fragestellung und dann kann man auf diese Fragestellung
hinzuarbeiten. Dann weiß man genau, welche Spalten brauche ich
jetzt gleich. Spaltenzugriffe sind
in Pandas, finde ich, super, super easy
und convenient. Man gibt im Prinzip einfach nur
von seinem DataFrame-Objekt per
.syntax den Spaltennamen an oder in
eckigen Klammern wie bei einem Listenzugriff.
Jetzt muss ich gerade genau überlegen.
Doch, da geht der Spaltenname
auch. Ja, es gibt
zwei Interfaces. Es gibt halt mit
man kann halt entweder den Namen
nehmen oder man kann halt auch den numerischen Index
nehmen. Das ist Log
und I-Log, glaube ich, sind die unterschiedlichen
Funktionen, die man da aufrufen kann.
Aber also ich würde auch eigentlich
immer eher, also mit den Indizes
ist eine ältere Geschichte und
ich würde eher die Namen immer nehmen, weil das
klarer ist, was da eigentlich gemeint ist.
Und die werden dann irgendwie mit GroupBy irgendwie so vorsortiert
oder sowas und dann gibt es irgendwelche Alternativen und dann kann
man die in Beziehung setzen und dann
alles plotten? Also erst mal
hat man Zugriff auf seine tabellarischen
Daten. Und da kann man sagen,
ich möchte jetzt Spalten A,
B und E plotten
auf einer X-Achse,
die ist in Spalte D meinetwegen.
Aber nur die roten.
Oder die roten und die gelben vergleichen. Genau.
Das ist dann der zweite Schritt,
dass man anfängt, vorher zu
aggregieren. Man kann dann
überlegen, will ich
nur bestimmte Gruppierungen haben?
Es gibt Funktionen, die heißen GroupBy.
Es gibt auch Funktionen, um eine kumulative Summe über irgendeinen Datensatz direkt per Funktion aufzurufen.
Das ist etwas, was man auch einfach plotten möchte.
Dass man sagt, okay, ich habe jetzt hier meine Daten und ich plotte dahinter in einer zweiten Serie auch noch die kumulative Summe.
Dann ist das quasi per einzelnen Funktionsaufruf in Pandas möglich.
Das ist spannend für die ganze Anwendung, wenn man irgendwie so kategorisierbare Daten mit verschiedenen Merkmalen hat und man dann bestimmten Merkmalen, bestimmte Wahrscheinlichkeiten zuordnen will, also mehrere Merkmale hat, also keine Ahnung, Leute ab zwei Meter und trotzdem unter, weiß nicht, 70 Kilo und welche Wahrscheinlichkeit haben die für bestimmte Dinge?
Genau, da kommen wir in einen anderen Bereich so ein bisschen rein und das ist Indizierung auf Basis von Boolean Werten. Also man kann jetzt zum Beispiel sagen, ich möchte aus meinem Datensatz eigentlich nur alle Zeilen auswählen, in denen Spalte A, was zum Beispiel die Höhe sein könnte, sagen wir Höhe eines Menschen kleiner als 1,80 Meter und größer als 1,60 Meter ist.
Und dann würde der mir entsprechend einen Slice aus meinem Data-Frame rausgeben, der nur dieser Bedingungen entspricht.
Was wird denn da technisch erzeugt? Also macht der eine Kopie der Tabelle mit diesen Werten oder setzt der halt dann noch eine neue Tabelle daneben mit so Bolian-Werten, ist wahr, ist falsch?
Oder macht der auch so einen Index, den er nur liest?
Gut, also meistens wird tatsächlich, wenn man jetzt irgendwie da irgendwas extrahiert, wird kopiert. Man kann aber auch sagen, dass es nicht kopiert werden soll.
Ja, also das sind meistens diese Boolean, also im Grunde erzeugt das halt eine Spalte, wenn man jetzt zum Beispiel sowas hat, man sagt DF, eckige Klammer auf, irgendwie, DF-Funktionalität ist größer irgendwas und DF-Funktionalität ist kleiner irgendwas.
Bullshit-Ausdruck sozusagen dann halt
irgendwie in eine Spalte verwendet,
wo dann irgendwie in jeder Zeile True oder False
drinsteht. Und dann wird das halt,
wenn man jetzt zeilenweise filtert,
werden halt alle Zeilen,
die halt True sind, rausgesucht
und alle anderen werden halt ignoriert quasi.
Und
ja, ganz genau, wie das
technisch unten drunter funktioniert, weiß ich jetzt aber auch nicht.
Und
ja, das sind halt so,
ich kann mir vorstellen, dass irgendwie so ein
NumPy hat irgendwie als Feature drin, dass man Sachen,
dass man so Masken verwenden kann, aber ich bin mir
nicht sicher, ob es wirklich verwendet wird, keine Ahnung.
Egal, muss man halt nochmal genauer nachlesen.
Ja, und
dann kann man da
irgendwie weitere Dinge mitmachen.
Das ist halt recht
schön, schöne Methode,
um da halt irgendwie Sachen rauszuselecten. Vielleicht kann man
an der Stelle auch mal grad eine
Blogartikel-Reihe erwähnen, das fällt mir da grad ein,
die ich immer
wieder, wenn ich irgendwie Leuten
Panas Erzähler
auch mit erwähne, weil die so toll ist.
Das ist von Tom Augsburger
Ja genau, das heißt
Modern Pandas
und das ist Teil 1
bis, ich weiß gar nicht wie viel es gibt
bis 8
momentan
Kenne ich noch gar nicht, muss ich auch mal reinschauen
Ja
So lernt man immer dazu
Genau und der beschreibt
halt sehr ausführlich, wie das mit dem Indexing
halt eher so aus User-Perspektive, was man damit alles
machen kann, funktioniert.
Und
ja, also gerade wenn man jetzt nicht nur
einen Index hat, das ist auch etwas, was halt
Pandas kennt, was ich von Datenbanken
so nicht kenne. Also Datenbanken bedeuten
Indizes ein bisschen was anderes als halt jetzt bei Pandas.
Man kann halt bei Pandas
auch mehrdimensional Indizes haben und dann da halt
irgendwie kreuz und quer verschachtelte Abfragen
macht. Und da
wenn man das sich so zuerst anguckt,
dann raucht einem da relativ schnell so der Kopf.
Aber wenn man tatsächlich diese
Probleme hat, dann kann das ultra praktisch
sein, wenn man da irgendwie sich mit auskennt
und diese Modern Pandas Serie ist halt eine,
wo man das sehr schön
sehen kann, wie das funktioniert.
Im ersten Artikel werden
glaube ich da irgendwie so halt
diverse Indizie-Geschichten erklärt
und dann gibt es halt einen Artikel
nur zu Method Chaining
und ja, dann
eins zu Indizes
und da wird dann auch nochmal das alte
Interface
gezeigt und halt, was man jetzt
mit dem neuen Interface an Dingen machen kann
und da gibt es halt wirklich verrückte
Abfragen, die man
Also das Ding auf jeden Fall ist wieder
super spannend, was der neueste heiße Scheiß
ist. Was ich jetzt da gekannt habe, ist auch
die einzige Quelle, deswegen habe ich jetzt den Vergleich natürlich
wieder nicht, ist diese Einführung in
Python mit Data Science
oder Data Science mit Python von Jake Wanderplast
Da gibt es auch ein schönes Artikel
zu Pandas drin, das ist auch
frei irgendwo bei GitHub
Ja, die Notebooks
Und sogar als Notebooks, die er alle hoffentlich hat
hat er irgendwie unter MIT-Lizenz da online gestellt
und da kann man auch genau die Sachen als Notebooks
direkt alle ausprobieren. Das ist ein tolles Beispiel für
diese, glaube ich, die einfachen
so die Basissachen drin, dass man so das grundsätzliche
alte Prinzip mal versteht, das man direkt dann mit
Pandas potten kann, ich glaube über den Untergang der
Titanic oder sowas.
Ja, sonst benutzen die
Tutorials oft gerne den Iris-Datensatz.
Da geht es irgendwie um
Blütenlänge und Breite und
das war mir immer ein bisschen sympathischer
als Biologe.
Also welche Klassen jetzt wie oder wie viele Frauen, Männer und wie viele Jungs und Kinder untergegangen sind, wie viele nicht.
Ja, genau. Das ist auch super spannend mit diesen Multi-Level-Indizes.
Da sollten wir gleich auch nochmal vielleicht ein paar Minuten uns Zeit für nehmen.
Für den Moment sei vielleicht auch nochmal erwähnt, wenn man jetzt ein Pandas DataFrame haben möchte
und man importiert das nicht aus einer Datei oder aus der Zwischenablage,
wie komme ich denn überhaupt zu meinem DataFrame-Objekt?
Und du hast eben gefragt,
kann man da vielleicht Dictionaries benutzen?
Ja, kann man tatsächlich.
Also wenn ich in Python schon ein Dictionary habe,
was Keys und als Values Listen hat,
dann kann ich einfach mein DataFrame erzeugen
mit pandas.dataframe oder pd.dataframe,
wenn man pandas als pd importiert,
und da reingeben, mein Dictionary.
Dann macht er automatisch aus den Keys Spaltennamen
und aus den Values, aus den Listen
macht er dann meine
Series.
Hat natürlich zur Bedingung, dass die gleich
lang sind. Ja. Sonst gibt es da
einen Fehler. Ich weiß gar nicht, ob der da mit
NA auffüllt oder ob der
Ja,
außer dass es einen Fehler wirft.
Ich weiß es aber auch nicht. Es gibt auch irgendwie so eine andere Funktion.
Ich weiß jetzt nicht, bei was es genau geht, wenn man halt
so ein DataFrame über so ein NumPy-Array hat oder
sowas, dass der automatisch neue Spalten
erzeugen kann, die er dann irgendwie
fortsetzt. Ich weiß nicht, ob das
linear passiert oder sowas, habe ich irgendwie kurz entdeckt.
Wenn man einfach eine neue Spalte
erstellt dann, wenn man schon drei oder vier hat,
dass du dann, wenn du die fünfte erstellst, einfach
dann neue Werte reinbaut.
Kann sein,
weiß ich nicht so.
Vielleicht habe ich auch wieder irgendwelchen Quatsch erzählt.
Ich weiß gerade nicht genau, was du da
meinst.
Jetzt habe ich das Buch natürlich zu Hause liegen lassen.
Irgendwo nachgeschlagen.
Buch ist aber auch ein gutes
Stichwort.
Und man kriegt ja immer den gut gemeinten Ratschlag, guck doch mal ins Handbuch.
Das Pandas-Handbuch ist tatsächlich länglich.
Es hat 2.900 irgendwas Seiten.
Davon sind rund 900 so die Basisfunktionen, 1.400 nur die API-Referenz und dann nochmal weiterführende Informationen.
Hast du es durchgelesen?
Nee.
So bei aller Liebe, das ist dann doch etwas viel.
aber man kann halt
relativ schnell kapitelweise,
wenn man was ganz Bestimmtes sucht,
da reinspringen. Okay, so als Index.
Es ist auch alles, also verlinktes
wie heißt das, Table of Contents,
Inhaltsverzeichnis, genau.
Verlinktes Inhaltsverzeichnis, man kommt schnell dahin.
Ja, die Dokumentation
von Panas ist auch sehr gut, aber auch manchmal,
also die ist schon etwas
trocken oder so, manchmal muss man sich schon so ein bisschen
ein bisschen quälen.
Vielleicht liegt das an dem Tabellenthema?
Könnte, vielleicht liegt es einfach am Thema.
Sollte man vielleicht eher
irgendwie Schreiner werden oder so.
Das ist vielleicht irgendwie,
ja, das überlege ich mir manchmal.
Das wäre toll.
Ja, aber
genau,
ja,
stimmt, was hatten wir?
Was gibt es für Datentypen, so Serien,
Data Frames, Panels?
Was kann man damit machen?
Ja, so, genau.
Man kann auch sehr viele Dinge,
die man sonst vielleicht mit einer Datenbank machen
würde, damit tun. Und das hat ja auch
so den Vorteil. Also das kann ich auch nur, ich finde
die Art, also das User-Interface
von Pandas ist halt
ziemlich angenehm und ist auch relativ kurz.
Also wenn du mit einer Datenbank arbeitest und
SQL-Statements schreibst, das geht natürlich auch,
aber das ist halt viel
umständlicher.
Und Pandas hat da halt eine sehr schöne
UI
eigentlich.
Und man kann viel damit machen, was man halt
auch mit einer Datenbank normalerweise tun würde. Und insofern
kann ich das auch nur empfehlen, wenn man jetzt irgendwie so ein Datenbankproblem
hat. Man kann auch irgendwie die komplette Datenbank,
meistens sind die ja nicht so groß, auch irgendwie in Pandas
sich reinholen oder als Data Frames aus der Datenbank
ziehen und dann da irgendwelche Dinge machen
und dann schon mal, wenn man dann weiß,
wie es geht, dann kann man es hinterher auch in SQL machen.
Aber vieles von dem
lässt sich auch locker in Pandas mal ausprobieren,
weil Pandas hat ja eben auch solche Funktionen wie
man kann Joins machen,
man kann halt Data Frames Merge, also da heißt das
dann, also ich glaube, da verwendet man
eher einen Aufruf Merge oder so, aber im Grunde
macht es dann halt auch ein Join zwischen
zwei DataFrames. Dann kann man angeben, auf welchen
Spalten gejoined werden soll und solche
Dinge. Und
genau, eben all diese Group-By-Geschichten.
Gibt es tatsächlich so eine Funktion, wie man
eine Datenbank in DataFrame bekommt und
andersrum, wie man eine DataFrame in irgendeinem Datenbanktyp
speichert? Ja, ja.
Also für alle Datenbanken gibt es da Adapter,
mit denen man die Daten noch auslesen kann.
Genau, also diese Import-
Export-Geschichten. Also wir haben
nur über Import gesprochen,
aber Export gibt es halt auch für
alle diese Datentypen. Warum schreibt dann
irgendjemand noch SQL-Statements?
Ja doch, also
manchmal, es kann schon sinnvoll
durchaus
sinnvoll sein. Also wenn du an der Datenbank ja auch
irgendwas manipulieren willst an Werten, dann musst du es ja tun.
Du kannst ja gar nicht, kannst auch
ein Pandas machen, aber dann hast du das Problem, musst es ja irgendwann wieder
zurück in die Datenbank schreiben.
Dann man klöscht eine neue Datenbank.
Ja.
Und gegebenenfalls
ist das, was du in deinem Speicher bearbeiten
kannst, auch
kleiner als das, was
in der gesamten Datenbank ist. Das heißt,
beim Import würdest du schon nur einen Teil
aus der Datenbank nehmen, kannst damit
aber dann relativ komfortabel
rumspielen.
Tatsächlich, der Befehl
ist Join, auch
in DataFrames. Ich verwechsel es auch immer wieder,
deswegen habe ich gerade mal kurz nachgeguckt.
Und es gibt noch Concatenate,
da kann man aus einem DataFrame
Spalten in ein anderes
reinziehen.
Ja, und dann, genau,
solche, eben, es gibt
so Datenmanipulationsgeschichten,
eben Join, Merge,
dann gibt es noch
solche Sachen wie,
genau, das ist auch schwer
zu erklären, wenn man das jetzt nur hört,
fürchtig,
sowas wie Pivot,
Unpivot, Melt,
Stack, Unstack,
sehr praktische Geschichten, aber ich weiß jetzt ehrlich gesagt nicht genau,
wie ich das erkläre.
Ja, du kannst, also wenn du,
Okay, ich versuche es mal einfach, wenn du jetzt
du machst im Grunde aus einer
aus Dingen, die in einer
Spalte stehen, machst du mit
Pivot irgendwie zusätzliche Spalten.
Also ich bin
gerade völlig auf den Kopf gefallen. Ich habe es natürlich mit der
Transformation gerade verwechselt.
Transpose, ja.
Das ist relativ einfach, aber
Pivot macht schon so ein bisschen kompliziertere
Dinge. Das aggregiert irgendwas zur besseren Auswertung.
Ein Widerfall, doch?
Nee, das, das, ja, also
manchmal hat man Daten halt in einem Format,
in dem man schlecht plotten kann.
Und manchmal braucht man halt Dinge, die
in einer Zeile, die irgendwo in einer Zeile stehen,
die möchte man als Spalte haben, um dann halt die Spalte
besser plotten zu können. Und dafür fällt man dann auf
Pivot. Und dann, genau,
die umgekehrte Funktion dazu ist Melt.
Und
die, aber eigentlich
noch allgemeineren Funktionen, die funktionieren dann eben
auf so Multilevel-Indizes
und halt Stack und Unstack.
Aber das kann auch sehr schnell
ein bisschen überfordern.
Also ich kann sagen, so aus dem
Biologenalltag, dass ich Pivot und Melt
nie benutzt habe. Einfach
weil die vielleicht auch
zu viel Magie im Hintergrund noch machen können.
Stack und Unstack aber
sehr häufig, weil
in der Realität
sind, wir hatten ja eingangs über die
Excel-Tabellen gesprochen, die nicht
immer ganz maschinenlesbar sind.
Es gibt noch den Zwischenwert, wo
die zwar maschinenlesbar sind, aber
mehrere Level von Indizes haben und wenn die mehrere Level von Indizes haben, man könnte
sich das zum Beispiel vorstellen wie, ich hatte eben noch ein Beispiel im Kopf, sowas
wie Klausurnoten nach Semestern in zwei verschiedenen Gruppen, sagen wir mal Biologen versus Chemiker
oder sowas, wie die in der Chemieklausur abschneiden im ersten Semester, im zweiten Semester.
Und dann hat man diese Gruppierung einmal, zu welcher Gruppe gehören die Personen an,
aber dann hat man auch für jede Zeile im Prinzip eine spezifische Person.
Das heißt, mehrere Personen teilen die gleiche Gruppe, also Biologe oder Chemiker,
aber jede Person hat eigene Noten in Semester 1, in Semester 2.
Wenn man das jetzt, jetzt muss ich kurz überlegen, in welche Richtung man das stacken würde,
dann würde man im Prinzip sagen, ich schreibe jetzt jede Person einzeln als Zeile auf
und habe eine neue Spalte, wo die Gruppe nochmal als sich wiederholender Wert mit drin steht,
sodass ich wegkomme von, ich habe im Prinzip zwei Zeilen, die jeweils vier Unterzeilen beinhalten,
Ich habe einfach acht Zeilen, wo in jeder dieser Zeilen die Gruppe nochmal explizit drinsteht.
Das macht es dann einfacher, nachher Gruppierungen zu machen.
Außerdem könnte man dann mit Unstack in die andere Richtung wieder sagen,
ich möchte das jetzt gar nicht nach den Gruppierungen unstacken, sondern nach Semestern zum Beispiel.
Und dann tauscht man plötzlich die Spaltenidentitäten.
Aber ja, also Tabellentransformationen einfach nur in einem Audio-Podcast zu erklären, ist sehr schwierig.
Genau. Ich weiß
gar nicht, ob es zu dem Stack-on-Stack oder
so Thema halt auch ein
Modern Pandas Artikel
gibt. Ich fürchte nein. Schade.
Ah ja, muss man einfach mal nach...
Also, ne, ich verlinke da einfach mal
einen Artikel zu, wie das so aussieht.
Wenn man das sieht, ist es eigentlich, dann kann man
es deutlich besser verstehen.
Ja, genau. Das sind so die Dinge, die
man damit dann tut.
Ja.
Ja, vielleicht nochmal dieser Pivot kurz,
das wart ihr gerade kurz dabei, das sind wir kurz
abgeschreibt. Also was
macht man damit jetzt genau? Also ich kenne das irgendwie jetzt auch aus Excel,
dass man irgendeine Auswertung hat, man hat dann irgendwelche
Datenblätter oder sowas und dann möchte
man dann irgendwelche Aggregate
irgendeinem Endnutzer
auf einem Auswertungs-Dashboard
zur Verfügung stellen und da wird dann
irgendwas zusammen gerechnet.
Ja, Excel genau kann ja auch
sowas, so Pivot-Tabellen.
Also ich habe hier gerade mal das
Data-Science-Cheat-Cheat-Pandas
offen. Können wir auch nachher verlinken.
Und da steht
im Wesentlichen drin, dass
Pivot Table, wie gesagt, ich habe es noch nie benutzt,
aber dass es
eine Pivot-Tabelle macht,
anhand von
einer Spalte gruppiert
und dann aber über andere
Spalten eine Funktion aufruft.
Das kann zum Beispiel sowas sein wie Mittelwert oder
eine Summe oder
nahezu beliebige Funktionen.
Möglicherweise habe ich das auch nie benutzt, weil ich die Excel-Funktion nie benutzt habe.
Was ich allerdings öfter benutzt habe, ist die Funktion Apply.
Und Apply erlaubt einem jetzt innerhalb eines Data Frames auf Basis einer Achse sozusagen eine Funktion auszuführen.
Das kann auch wieder nur Mittelwert oder Standardabweichung sein.
Das können aber auch komplexere Funktionen sein.
Und also für die, die vielleicht schon Hintergrund in R haben,
da gibt es T-Apply und L-Apply für Zeilen, Spalten und was weiß ich nicht alles.
In Pandas DataFrames gibt es im Wesentlichen Apply und man gibt die Achse an.
Also soll das auf Reihen, auf Spalten agieren.
Und dann gibt man eine Funktion an und die wird dann entsprechend für eine komplette Spalte
oder eine komplette Zeile ausgeführt.
Ja, das ist vielleicht eben genau, das ist auch noch ein ganz wichtiger Punkt, den wir noch gar nicht erwähnt haben, dass man, man kann, was man nicht tun sollte, ist über Data Frames iterieren und dann in der Vorschleife da irgendwelche Dinge mitmachen, das könnte man sich auch vorstellen, dass man das so tut, weil das, wenn man das, wenn man aus Python kommt, dann macht man das ja mit Listen normalerweise so, aber das geht halt nicht, oder das geht schon, ist halt nur dann sehr, sehr langsam, während halt, wenn man jetzt Apply aufruft, dann ist das halt ziemlich schnell.
weil unten
drunter, weil eben
Vorloops in Python sowieso langsam sind
und man dann eben keine Vorloop machen muss,
sondern das läuft halt alles irgendwie
in den entsprechenden, also kommt
je nachdem, wie der Datentyp ist,
aber möglicherweise halt landet das in
einer dieser optimierten Vortragsbibliotheken,
die unten drunter unter der Lampe liegen
und es ist halt auch so, dass es dann
in gewisser Weise schon parallelisiert wird
oder halt diese, ich weiß jetzt gar nicht,
wofür SIMD steht,
diese Instruktionssets, diese
Single Instruction Multiple Data.
Ah, okay. Ja, genau.
Super. Dankeschön.
Ja, man spricht da auch von
Vektorisierung. Also man
kann halt
mit einem Taktzyklus halt
mehrere
Operationen ausführen, weil
man hat so super lange Register.
Weiß ich nicht, vielleicht 512
Byte oder so.
Und da sind dann halt viele,
wenn man jetzt Integer hat, 4 Byte
Werte drin und die werden dann halt
alle addiert gleichzeitig oder
multipliziert oder sowas.
Und man zerlegt halt ein komplettes
Array sozusagen, auf dem man dann
irgendwelche Dinge macht, halt in diese Blöcke
und braucht dann halt viel weniger Takte,
als wenn man da einen Vorluft drüber machen würde.
Ja, und das
macht Sachen super schnell.
Man hat halt irgendwie so
Python-Interface und ein Jupyter-Notebook,
das sieht dann halt so aus, als wäre man
super high-levelig, aber wenn man eine Operation macht,
kann es sein, dass dann tatsächlich etwas sehr, sehr
Optimiertes passiert und es sehr schnell
ist und wenn jemand da hingehen würde,
würde er es in C schreiben, ist er möglicherweise
deutlich langsamer, wenn er
nicht genau weiß, was er tut.
Und das ist natürlich für viele
Leute auch total überraschend.
Und das ist auch eine sehr, sehr, sehr, sehr schöne Geschichte.
Aber ja, man muss halt
auch so ein bisschen eine komische
Syntax dafür halt in Kauf nehmen.
Man kann halt nicht mehr For-Loops machen, man muss halt
immer Apply schreiben und dann halt
eine Funktion übergeben. Oft übergibt man dann halt so anonyme Funktionen.
Schreibt dann Apply und dann Lambda, X
und dann kriegt man halt irgendwie einen Wert übergeben,
macht dann damit irgendwas.
Comprehensions oder sowas
kann man auch vergessen, genau, das selbe Problem.
Genau, das geht alles nicht mehr.
Man schreibt halt alles nur noch
ja, quasi,
man schreibt eigentlich fast alles in Apply. Ich weiß gar nicht,
ob es da noch andere Funktionen gibt, die so ähnlich sind wie Apply.
Naja.
Nee, das ist eigentlich
immer Apply, ja.
Ja, und
dann chainet man halt die Sachen hintereinander.
Man kann halt,
diese Methode liefert dann halt
das Ergebnis von dem Apply zurück, dann
ruft man darauf wieder was anderes auf und dann
hat man halt eine ganze Reihe von so hintereinander
gechainten Apply-Aufrufen unter Umständen.
Und ja.
Das ist auch
witzig. Fällt mir gerade noch
zu dieser Vektorisierungsgeschichte ein.
Früher
haben auch Leute irgendwie
erzählt, naja, ach,
das mit der Parallelisierung,
das ist ja alles gar kein Problem, wenn wir jetzt viele CPUs haben,
so irgendwie die
Steigerung der Taktfrequenzen war ja dann irgendwann auch schon
vor längerer Zeit irgendwie vorbei,
mehr oder weniger, und man muss halt, man kriegt halt
mehr Prozessoren, also Moore's Law ist halt noch nicht
wirklich weg, weil sich das eigentlich auch nur auf
die Transistoren, nicht auf die Geschwindigkeit
als solche irgendwie bezieht.
Aber
dann hieß es halt so, naja, das ist kein Problem,
wenn man mehrere Prozessoren hat, da gibt es dann bestimmt Compiler,
die das automatisch parallelisieren oder so.
Nee.
Ist nicht passiert, wird auch nie passieren.
Dass Sachen automatisch parallelisieren geht
halt nicht. Und das Schlimme
ist, selbst sowas wie automatisch
vektorisieren geht halt nicht.
Weil dummerweise,
wenn man jetzt in C,
wenn man sich jetzt mal vorstellt, man schreibt
eine Vorschleife, die jetzt zwei Vektoren addiert,
also sagen wir so,
die macht einfach nur
C gleich A plus B. Wobei jetzt
C, A und B sind halt Vektoren
der gleichen Länge.
C ist der, der erzeugt wird.
Und man macht halt
einfach vor, die das tut, dann denkt man sich
jetzt, könnte doch eigentlich der Compiler
hingehen und das irgendwie
in diese Single Instruction Multiple
Data Prozessor
Befehle umwandeln und dann irgendwie
das deutlich schneller machen, stellt sich
raus, nein, kann er nicht, weil in C
ändert das halt die Semantik
von deinem Programm. Weil
es könnte ja auch sein, dass dieses C irgendwie
wieder was mit deinem A und deinem B zu tun hat und
die Reihenfolge, in der du Sachen addierst,
sich auf die nächste Addition irgendwie auswirken.
Sodass halt, wenn du das in der Vorlog machst,
kommt halt was anderes raus, als wenn du das parallel machst.
und dann muss der
Compiler natürlich sagen so, nee, kann ich nicht automatisch
optimieren, weil weiß er nicht, vielleicht ist
das irgendwie, ist das die Programmlogik
dass das so sein muss
so, das heißt, bei sowas Simples geht's schon nicht
also man kann natürlich irgendwie dann so
Hinweise an den Compiler
dazu schreiben, also man sagt so, hier ist okay
darfst du schon optimieren, mach da mal
aber so generell kann
ein Compiler das nicht machen und damit
ist es natürlich schon irgendwie, ja
und das ist einer der Gründe, warum das
auch in Fortran so viel schöner funktioniert
ist, da gehen solche Sachen nicht, da kannst du
nicht, kann nicht das Ergebnis
einer
Addition, wenn du
zwei solche Arrays addierst,
kann nicht sich auswirken
auf die nächste, sozusagen. Das C kann
nicht irgendwie wieder zu A oder zu B gehören,
sodass, da das ausgeschlossen
ist, kannst du in Fortran solche
Operationen halt automatisch vektorisieren. Das ist einer der Gründe,
warum das halt irgendwann auch alles irgendwie Fortran ist.
Auf der anderen
Seite, das müsste nicht unbedingt, du kannst auch ein C machen,
oder ein C++, wenn du das halt dem Compiler
entsprechende Hinweise gibst. Aber es ist alles irgendwie
nicht so ganz einfach.
Wahrscheinlich will man sich da auch nicht
mit rumschlagen. Aber wenn man einfach so Panas verwendet,
dann passiert das ja alles automatisch und man hat nichts damit zu tun.
Das ist gut.
Ja, genau.
Vektorisierung hatten wir dann.
Genau, was wir vielleicht noch mal
ein bisschen detaillierter
ansprechen können, ist irgendwie das Plotting.
Also es gibt für jedes DataFrame erstmal einen DotPlot und da kann man noch ein paar Parameter angeben und seinen Plot konfigurieren.
Es gibt auch noch eine Reihe von anderen Funktionen.
Ich habe die auch nie alle im Kopf, aber da gibt es irgendwie noch Scatter und Box und da hat man dann verschiedene Diagrammtypen auch standardmäßig schon vorimplementiert,
damit man sich nicht mehr darum kümmern muss, die Plot-Funktion entsprechend durchzukonfigurieren, sondern man bekommt direkt die Plots, die man haben möchte.
Und eine Sache, die ich ganz schön finde, ist, man kann als Spalten da auch wieder die Spaltennamen angeben.
Man muss jetzt nicht irgendwelche Koordinaten in dem DataFrame angeben,
sondern man sagt, plotte bitte Höhe, Breite, Länge gegen Zeitachse und dann passiert das genau so.
Das ist einfach auch dann deutlich besser lesbarer und wartbarer Code, den man schreibt.
Ja, ja.
Welche
präferiert ihr von diesen Plotting-Bibliotheken?
Also jetzt irgendwie Matplot mit Seaborn
oder dann doch Bookie oder?
Ich verwende
meistens Seaborn tatsächlich
in Notebooks, aber
es kommt halt darauf an,
auf den Einsatzzweck. Also meistens
müssen die für mich nicht interaktiv sein
und dann verwende ich halt Seaborn, weil es einfach
netter aussieht, als Matplotlib direkt zu verwenden
und das ist halt auch irgendwie einfacher.
Es gibt halt manche Plots, das geht auch mit
Matplotlib, aber
es ist halt schon so ein bisschen, also ehrlich
gesagt, ich mache das meistens so,
dass ich auf Seaborn,
auf der Seaborn-Dokumentation halt dann so
angucke, was ich so grob brauche und dann
scrolle ich halt durch die Beispiele, bis ich irgendwas gefunden habe, dann
kopiere ich den Aufruf und modifiziere
den so lange, bis es halt irgendwie funktioniert.
Wenn man
jetzt mit Matplotlib hingehen würde und
das so nachbauen würde, dann
ist das halt
deutlich schwieriger und
es geht natürlich auch, Matplotlib,
C1 baut darauf auf und Matplotlib ist sehr
mächtig, aber die API
ist nicht so ganz einfach und
eigentlich musste ich da nie, da ich auch nie
so wirklich komplizierte Visualisierung mache, muss ich da nie
so tief einsteigen, dass ich das irgendwie
wirklich gebraucht hätte, sondern für mich reicht C1 meistens
aus und dann gibt es aber natürlich auch
noch Fälle, wo man das halt
so ein bisschen interaktiv braucht,
wo man da drin zoomen können möchte
oder man möchte es auf einer Webseite haben
und dann
ist eher sowas wie Bokeh oder Plotly
das, was man da verwenden möchte.
Also Plotly
habe ich glaube ich auch schon mal für so
Dashboards oder so kann man das ganz gut verwenden.
Man kann tatsächlich
relativ einfach eben, wenn man jetzt
eine Datenbank hat oder so, dann zockt man daraus wieder
Data Frames und
die kann man dann sehr einfach mit Plotly
irgendwie auf einer Webseite visualisieren
und dann können sich die
Leute, die das angucken, halt auch dann
den Bereich, der sie interessiert, halt irgendwie
auswählen und daran zoomen
und so. Also ich bin auch
totaler Plotly-Fan.
Im Wesentlichen, was da rauskommt
als Graph ist eine
kleine HTML-Seite oder auch
nur ein Snippet, das man einbinden kann.
Und zugrunde liegt
dem D3JS, das ist eine Visualisierungs
Library in JavaScript.
Und das
hat super viele Funktionen, aber ich
benutze das hauptsächlich dafür,
dass man einen Mouse-Hover auf den Datensatz
hat. Man fährt
halt über den Graph drüber und man sieht den exakten
Wert nochmal an der Maus. Das ist
so die wichtigste
Funktion, die ich an Plotly immer wieder nutze.
Das kann man aber auch
beliebig weiter eskalieren noch. Es gibt jetzt
neu von Plotly Dash.
Das ist ein ganzes Dashboard
mit Plotly-Graphen, geschrieben
in Flask.
Und das kriegt man auch super schnell
hochgefahren. Und es gibt sogar inzwischen
ein Gitterprojekt, das eine Django
Anbindung für dieses Plotly
Dashboard macht. Also
da kann man dann im Wesentlichen
eine ganze Website mit Datenvisualisierung
als Django
Applikation direkt ausliefern.
Was auch ziemlich nett ist,
habe ich aber noch nicht im Detail ausprobiert.
Gibt es sowas auch für R?
Ja, ja, ja. Man muss sogar sagen,
der Dash ist halt so ein Nachbau von etwas,
was halt in R super populär
ist. In R heißt das Shiny.
Ja, genau. Und
das ist eigentlich immer noch so ein bisschen
der Goldstandard für diese
Geschichten, weil, also ich weiß nicht
wie weit, also ich habe jetzt auch schon
lange nicht mehr angeguckt, aber wie weit Dash da jetzt
ist, ob sie das schon
da dran sind, aber
man hört immer noch,
dass viele Leute sagen, ah, aber Shiny
ist schon irgendwie toller und ich mag das
lieber als irgendwie, da gibt es noch keine so
richtige Alternative in der zweiten Welt zu.
Ich meine, da guckt auch
jeder vom anderen ab, ehrlicherweise.
R hat auch irgendwann angefangen mit diesen Notebooks und hat jetzt die Möglichkeit, ganze Berichte in Markdown zu mischen mit ausführbaren Code-Zellen. Also im Prinzip das, was man mit Jupyter Notebooks für Python hat, gibt es auch in R. Also es ist so eine Ko-Evolution der beiden Analyse-Workflows, sage ich mal.
wobei man sagen muss, dass die ursprüngliche Idee
für diese Notebook-Geschichte
die Art, wie wir das, das kommt aus Mathematika
und
es gibt schon ganz lang,
aber es hat sich nie so
wirklich durchgesetzt, bis dann
das
dann jemand als
eben, bis Leute das dann halt
dieses Jupyter-Projekt
aus einem IPython-Interpreter
halt irgendwie rausgewachsen ist,
bis das da implementiert wurde.
Und ich habe jetzt auch letztens gehört, dass jemand
Und Stephen Wolff.
also den Mathematiker-Autor
da irgendwie gefragt hat,
warum das jetzt, warum das eigentlich
nicht Open Source wäre, weil das hätte
sich doch jetzt irgendwie durchgesetzt und voll toll
und so und das,
die Idee war ja vorher schon da, aber
ist unbekannt geblieben und
äh, ja,
Stephen Wolfram hatte darauf glaube ich so,
ja, also ich hätte das ja schon gerne
als Open Source irgendwie veröffentlicht, aber das ging damals
nicht, weil es keine Distributionsmöglichkeiten
dafür gab, das wurde halt alles irgendwie auf
CDs und DVDs.
Tja.
Ja, es ist manchmal
komisch. Es reicht nicht
irgendwie, dass eine Idee super ist oder so, sondern
es müssen mehrere Sachen zusammenkommen, damit irgendwas
wirklich dann abhebt.
Und manchmal
ja, kommt dann
denken Leute, dass irgendwie eine Idee
erst kurz gibt oder so. Das gibt es hier schon ganz lange,
aber die Umstände waren halt nicht
richtig, sodass sie halt
vorher halt noch nicht abheben konnte.
Und bei diesen
Jupyter-Notebooks ist das halt schon so. Ich denke, das war
genau der richtige Moment und jetzt ist es halt groß
geworden.
Shiny, let's be bad guys.
Ich meine, gerade im Data-Science-Bereich,
wo man schnell viele
Dinge ausprobieren muss, ohne
Skripte von Anfang neu laufen zu lassen,
ist natürlich der
Killer-Anwendungszweck für diese
Notebooks.
Ja.
Ja, haben wir noch was hier für
Pandas? Ja, also Pandas ist ja nie
isoliert zu betrachten. Wir haben ja jetzt ganz viel
schon auch über NumPy gesprochen, über Seaborn und Matplotlib
und die eine Bibliothek, die ich eingangs
noch mit erwähnt hatte, war Stats Models
und die bringt da im Prinzip noch
eine Funktionalität rein, die ich persönlich auch erstmal nur von
A kannte und zwar ist das
Formeln
anzugeben, auf die man dann Fitting machen kann
oder die man auch plotten kann. Und diese Formeln,
das ist vielleicht erstmal ungewohnt, wenn man das noch nie gesehen hat, gibt man
im Wesentlichen irgendwie an als, sagen wir mal, eine Geradengleichung
y tilde x. Also eine Variable y,
die abhängig ist von einer Variable x
und als lineare Funktion zu verstehen ist.
Und in diesem Statsmodels gibt es die Funktion OLS,
um diese Formeln abzubilden.
Die kann man dann auch mit Pandas DataFrames zusammen benutzen,
um wieder Plotting zu machen.
OLS meint du Optimal Linear Squares Modeling?
Müsste, ja.
Ordinary Linear Squares oder so was?
Ich weiß es nicht mehr.
Also im Wesentlichen irgendwie lineare Gleichungen anzugeben.
Da gibt es auch noch ganz viele andere Möglichkeiten.
Das ist nur jetzt der einfachste Fall immer, wo man eine lineare Gleichung angibt.
Und diese Variablen, die man da angibt,
die können in meinem Pandas DataFrame zu finden sein.
Und dann kann ich das Plotting darüber machen.
Da kann ich einmal die Trendlinie direkt
plotten, ich kann das Fitting direkt über die Pandas
Data Frames machen. Also die
greifen da irgendwie, also alle diese
Bibliotheken greifen sehr stark ineinander.
Und da würde es
auch gar nicht reichen, die 2.900
Seiten des Pandas Handbuchs komplett zu lesen.
Man müsste
halt auch noch das NumPy Handbuch
komplett lesen und dann vielleicht das
Matplotlib Handbuch noch komplett lesen.
Also falls ihr die 2.900 Seiten Handbuch
gelesen habt, dann sagt mal Bescheid und schreibt uns eine E-Mail.
Ja, genau.
Statsmodels
kenne ich auch so, was Zeitreihenmodellierungs
Geschichten angeht, aber habe ich
noch nie so wirklich viel mit
gemacht.
Ich bin eher so bei
Scikit-Learn zu Hause und
also Maschinen-Learning-Bibliothek
und auch da ist es so, also meistens
bevor man halt irgendwelche
Daten in Modelle kippen kann,
muss man die halt mit Pandas einmal
aufräumen und dann war es halt so, früher musste man dann
immer noch so, okay, ich habe das jetzt in einem
Data-Frame, wie kriege ich die Daten jetzt
wie kriege ich die Daten
jetzt so,
dass ich die an meine Modelle verfüttern
kann und das war auch mal so ein bisschen problematisch
und das ist jetzt aber auch schon
die letzte oder vorletzte Version
von Cycle-Learn war auch kein
Problem mehr, weil man jetzt automatisch
auch, weil man jetzt auch nicht
früher brauchten die ganzen
also in Cycle-Learn heißen die
Estimators, Estimator API
die haben halt
NumPy-Arrays genommen und jetzt
mittlerweile nehmen die halt auch Pandas DataFrames
und die Spalten einmal halten
und wenn man halt irgendwie hinterher gucken
möchte, okay, was ist denn jetzt
wo gelandet und so und
dann kann man da auch mit den Spalten
Namen arbeiten und das ist alles sehr, sehr bequem geworden
und das greift halt auch da wiederum ineinander
und das ist halt eigentlich sehr schön.
Also das ist
ein großes Data-Science-Ökosystem
mittlerweile und das ist halt schon toll.
Ah, dazu fällt mir ein, genau,
Sparse Data ist natürlich
auch so ein Problem. Da gibt es
irgendwie einen Sparse-Type
von SciPy.
Das hat man früher immer verwendet.
Es gibt ein paar Modelle, die halt in Scikit-Learn mit Sparsen
Daten umgehen können. Also Spars
heißt
Daten,
bei denen die meisten Werte
Null sind.
Also zum Beispiel, wenn ich jetzt
eine Menge von Texten
in
Vektoren verwandle, dann
ist jedes Wort eine Dimension sozusagen
und das heißt, ich habe eine Tabelle mit
wenn ich einen kompletten
wenn ich eine Menge von Texten
in eine Matrix verwandeln
in so eine Feature-Matrix verwandeln möchte
und dann ist jedes Dokument ist eine Zeile
und die Spalten sind
halt die Worte, die drin vorkommen
dann sind halt, die kommen halt
die meisten
Worte, die es so gibt, in einem Text aber
nicht vor, das heißt, die allermeisten Werte sind halt null
und jetzt ist es halt blöd, das
halt dicht zu speichern, diese ganzen Nullen immer mit zu speichern
weil eigentlich interessieren die einen ja gar nicht und dafür gibt es dann so Sparse-Formate und dann gibt es dann ja CSA oder CSO-Formate in SciPy, aber das ist halt auch alles ein bisschen unschön und jetzt eben der letzten Release von Pandas war auch ein natives Sparse-Datenformat mit drin, das habe ich mir aber noch nicht angeguckt, aber es sieht auch interessant aus.
Ich weiß auch nicht, ob man das jetzt in Cyclet Learn schon verwenden kann, aber das ist, genau, das wird halt auch noch mit abgedeckt. Und ja, das ist auch noch so ein nicht uninteressantes Detail.
Gibt es noch andere Bibliotheken aus den Wetten, Zeit, Learn, Studs, Models, SciPy, die ganzen Visualisierungsgeschichten.
Oh ja, doch eine Geschichte auch noch wichtig, wenn man jetzt tatsächlich größere Datenmengen hat oder halt auch Operationen, die lange dauern und man hat irgendwie so eine dicke Kiste mit irgendwie, weiß ich nicht, 64 Prozessoren, irgendwie einem halben Terabyte Hauptspeicher oder so was und man ist so ein bisschen angeödet davon, dass das irgendwie immer nur auf einem Prozessor läuft, dann kann man da was tun.
Da gibt es ein auch sehr schönes Projekt, das nennt sich DAST.
Und damit kann man das halt so ein bisschen auf mehrere Prozessoren skalieren.
Also was das letztendlich tut, ist ein Data-Frame halt in viele Kleider zu hacken
und dann halt die Operationen halt auf Prozessoren zu verteilen
und dann halt das hinterher wieder zusammenzuführen.
Aber es kann halt, also ich glaube, mehr oder weniger beliebige Compute-Graphs
kann man da irgendwie angeben.
einfache Dinge sind halt einfach
damit zu parallelisieren. Wenn man komplizierte Sachen
machen möchte, dann muss man da auch so ein bisschen nachdenken
und dann halt eventuell
sich überlegen, wie man das halt ausgeführt kriegt, aber
im Grunde
funktioniert das so, man hat halt so eine Deferred
API, man sagt halt, was man tun möchte und dann am Schluss
sagt man irgendwie jetzt Collect oder so
und dann
ich glaube, ich weiß gar nicht, also
man ruft halt irgendwie eine Funktion auf, die sagt
so und jetzt rechnet das halt alles mal aus und dann
wird das halt auf die unterschiedlichen Prozessoren verteilt
wird alles ausgerechnet und am Schluss hat man
das alles wieder in einem DataFrame und
die Geschwindigkeit
hat sich dann, wenn man Glück gehabt hat,
irgendwie linear
skaliert
und man braucht nur noch ein Sechzigstel der Zeit
oder so.
Genau.
Das ist auf jeden Fall auch ein Ding, was man sich
auch angucken sollte, also was
Skalierungsgeschichten angeht. Ja, wenn die Datenmengen
dann noch viel größer sind oder dass sie halt nicht mehr
Hauptsprecher auf einer Maschine passen oder so,
dann muss man sich nochmal
was anderes überlegen. Dann
bleibt eigentlich nur, dass man
irgendwie dann Richtung Spark
geht oder sowas. Aber
diesen Fall hat man fast nie, weil
mittlerweile die Maschinen
so viele Hauptsprecher haben, dass das irgendwie kaum vorkommt.
Wenn es nicht mehr
in den Hauptsprecher passt, Geld dagegen werfen
und mehr Hauptsprecher besorgen.
Ja, wenn wir schon beim halben Terabyte angekommen sind,
da ist ja schon noch ein bisschen Platz.
Ja, geht eine ganze Menge rein.
Ja, so
Skalierung hatten wir jetzt auch so ein bisschen.
Wir hatten noch, glaube ich, dieses
Wes McKinney, hast du kurz erwähnt, da hatten wir, glaube ich,
einmal in unserer Weihnachtsfolge dieses 10 Things I Hate About
Pandas irgendwie. Ah, ja, ja, ja, genau.
Ich weiß nicht, ob da noch was
rauskam.
Ja, der,
also er arbeitet halt hauptsächlich
an dem Arrow-Projekt, da geht es darum,
eine neue Grundlage zu schaffen
und zwar nicht nur für Python,
sondern für
alle anderen Programmiersprachen
auch, weil man hat halt das Problem, dass man
man möchte eigentlich nicht,
wenn man Daten hat, die groß sind und
man möchte die nicht mehrfach
im Hauptspeicher halten, aber momentan kommt man nicht drum rum, wenn man
jetzt
beispielsweise in R und
in Python irgendwie auf Daten
irgendwas machen möchte, dann muss man die halt
irgendwie erst, wenn man die jetzt in Python hat,
serialisieren, irgendwo hin auf die Platte schreiben, dann in R
wieder einlesen und hat sie dann
im Endeffekt zweimal im Hauptspeicher, was natürlich irgendwie
doof ist und das Projekt
ist sozusagen
stellt halt
sozusagen Schnittstellen für alle Programmiersprachen bereit, aber
die Daten selber werden
nur im Hauptspeicher an einer
Stelle gehalten und dann kann man mit allen Sprachen, also
von Java bis C,
C++, Rust,
was auch immer, irgendwelche Leute schreiben gerade eine Query Engine
für Arrow in Rust,
Python A, darauf zugreifen
und da irgendwelche
Manipulationen drauf machen,
ohne dass es halt dann
jedes Mal eine Kopie macht. Und das ist natürlich auch
eine sehr, sehr interessante Geschichte,
weil das ist eben,
davon hatten wir es ja auch schon ein paar Mal
momentan, wenn man mit so Big Data
Geschichten, Hadoop-Clustern zu tun hat,
so ein Problem, dass man da nicht so gut an die Daten
rankommt.
Und
ja, das war auch eines der ersten Geschichten,
die Arrow gemacht hat, war
Parquet-File-Parser
zu implementieren,
sodass man halt zumindest die Files,
in denen die Daten liegen, halt irgendwie lesen kann.
Ja, und
das ist, glaube ich,
also mittlerweile funktioniert das
irgendwie fast allen Sprachen, dass man das
halt sozusagen als
Ersatz
für NumPy auch nehmen kann.
Also eine Geschichte ist so, dass
man in Pandas
das nicht so wirklich schmerzfrei in NumPy
aushauschen kann, weil das halt
viele Sachen in Pandas
beruhen halt darauf, dass ein Handball so ist, wie es ist.
Das wird halt schwierig. Da gibt es auch
eine Serie von Artikeln dazu,
nennt sich Pandas 2.0 irgendwie,
wo man dann halt überlegt, dass man die API
so nicht abwärtskompatibel ändert.
Dazu hat
Wes McKinney 2015 ein paar Artikel geschrieben.
Bisher ist da nicht so viel passiert,
aber man müsste, wenn man jetzt komplett auf Arrow umsteigen
wollte und so, dann müsste man da wahrscheinlich
viel auch an dem Frontend
von Pandas ändern und das wird dann
nochmal schwierig.
und
ist es so, dass
was auch noch in nächster Zeit bei Arrow
ansteht, ist, es gibt
so ein großes
Kluft zwischen dem, was halt im
Datenbankenbereich passiert ist
und dem, was halt im
Data-Science-Bereich passiert ist und da
geht es auch darum, das so ein bisschen
anzugleichen. Also was man zum Beispiel nicht hat, ist eine
Query-Engine für Arrow, also
da wird halt gerade geschrieben, also
ich glaube, das ist das Projekt für die nächsten 2-3 Jahre
in Arrow, ist halt so
wäre doch schick, da auch so eine SQL-Engine
drauf zu haben, sodass man halt
Error auch als
Ersatz oder Alternative
zu Impala oder sowas halt auf Clustern
verwenden könnte.
Weil das ist im Grunde auch eine SQL-Engine
in C geschrieben,
die halt
auf so einem
Hadoop-Cluster laufen kann.
Und dann
kann das aber viele der Sachen, die man halt
in Datenbanken hat, auch noch nicht. Also ganzen
Index-Geschichten und so.
Und
ja,
da läuft
das aber irgendwie so hin. Also ich meine, wenn man
sich jetzt so eine ideale Zukunft mal ausmalen
würde, könnte,
würde ich sagen, wäre das eigentlich sowas, man hat
eben so
einen In-Memory-Storage
Arrow oder so.
Man hat irgendwie
als Frontend etwas Pandas-ähnliches.
Es gab da auch
schon einen Ansatz von
eben auch wieder von Wes McKinney, das ist eine zentrale
Figur, das nennt sich Ibis,
das Projekt, wo es darum geht,
ein Superset
von SQL zu haben,
das möglichst pandasähnlich ist,
mit dem man aber all das
machen kann, was man sonst auch mit SQL-Datenbanken macht.
Und
ja, das halt auch so eine
Default-Execution-Geschichte macht,
dass man halt hinterher nur sagt, irgendwie man
definiert die ganzen Transformationen, Abfragen,
wie man da macht und am Schluss sagt man, so und jetzt
ausführen und dann geht das quasi
an so einen Cluster raus. Und das
ist mit SQL auch alles,
SQL ist sowieso blöd, weil
ja, diverse Geschichten
gehen halt mit SQL nicht so richtig gut, also man kann
auch Tests für SQL schreiben, aber das ist alles ziemlich hässlich
und man kann auch nicht so wirklich
Code sharen, also wenn jetzt, es gibt nicht sowas wie
Funktionen, aber wenn man jetzt
ähnliche Abfragen macht in unterschiedlichen
Kontexten, dann kopiert man oft
die Statements und so, das ist alles
nicht so schön und das ist halt
mit so einer Notation wie
in
Ibis
halt deutlich besser, weil da kann man das einfach in Funktionen
packen und die Funktionen woanders halt verwenden
und so und das geht halt viel schöner.
Ja, und das dann halt auch nochmal ändern.
Bei einem SQL-Statement könntest du das ja auch in eine Funktion packen,
aber das Problem ist, dann hast du halt genau dieses Statement. Du kannst
das Statement kaum ändern, außer du nimmst halt
ein ORM, aber ORM ist dann auch wieder eigene
Probleme und ja,
also ich würde mir eine ideale Welt
würde ich mir so vorstellen,
also für kleine Datenmengen funktioniert man das ja schon super,
bis auf diese kleinen Hässlichkeiten
wie eben None und
diese Block-Storage-Geschichten, aber das
kriegt man ja alles in den Griff mit der
Array-Extension-API.
Aber für große Datenmengen, dass man dann halt so
was ähnliches hat wie
Spark oder
auch der Doob, man hat einen großen Cluster,
wo dann in Memory halt die ganzen
Daten in Apache Arrow quasi
liegen und man dann
auf Arrow aufsetzend irgendwelche Query-Execution
Engines hat, die man
füttert von einem
Pandas-ähnlichen Frontend aus,
wo man dann halt definiert, was man
gerne hätte und das dann halt irgendwie
auf den Cluster verteilt wird.
Also man hat irgendwie so eine Art Array-Datenbank
verteilte, In-Memory-Array-Datenbank
mit so einer
vielleicht
Intermediate-SQL-ähnlichen Query-Engine hat,
aber so als Frontend
sowas wie Pandas, sodass man dann halt auch
wirklich großen Datenmengen einfach so
Transformationen
machen kann wie in Pandas.
Das wird vielleicht noch ein paar Jahre dauern, aber das wäre
Also das, was ich mir wünschen würde, was passiert.
Und dass man vielleicht irgendwann dann tatsächlich Panas 2.0 hat,
wo man nochmal komplett neu irgendwie diese ganzen Geschichten,
die in der Kombination mit NumPy halt nicht so toll sind, gelöst werden.
Aber das kann auch sein, dass das nie passiert,
weil so viele Leute jetzt Panas verwenden.
Ich sagte gerade noch, wenn der Jochen heute anfängt,
dann hören wir jetzt monatelang keinen Python-Podcast mehr,
aber es hört sich gut an, mach das.
Nee, ja, das Projekt ist ja schon, da gibt es ja Leute, ja.
Also ich kann es auch kaum erwarten,
aber es wird wahrscheinlich noch ein paar Jährchen dauern.
So schnell ist das nicht umzusetzen.
Ja, ja.
Ja, ich weiß nicht, von meiner Seite,
ich wüsste jetzt spontan nichts mehr.
Wenn ihr mich jetzt fragen würdet, fragt doch mal,
was sind so die drei wichtigsten Sachen,
die ich mit nach Hause nehmen muss, wenn ich mal mit Pandas
anfangen möchte. Was sind die wichtigsten
drei Sachen, die du mit nach Hause nehmen musst, lieber Simon, wenn du
mal mit Pandas anfangen möchtest? Ich würde
sagen, Describe, Plot und
Apply sind so die drei ganz
zentralen Dinge, die man sich
angucken möchte, weil da kann man
fast alles schon mitmachen.
Ja, okay.
Ja, ich würde sagen, Read CSV sollte man sich auch
mal angucken. Ja, okay, also
Datenimport, ja.
Aber sonst, ja, nee, klar, doch.
Ja, schön, schön.
Ja.
Schöne Strukturierung mit unseren Daten über Pandas.
Ich finde es hervorragend. Ja, dann würde ich sagen,
sind wir mit dem Pandas-Thema tatsächlich für heute
soweit durch. Und vielleicht machen wir noch
so ein bisschen Abschluss und erzählen noch ein bisschen
was von euren Lieblingspicks oder sowas
für, ja.
Erstmal.
Sieben, möchtest du anfangen? Irgendwie hast du einen Lieblingspick?
Irgendein Modul, was du...
Muss ich kurz einen Moment
drüber nachdenken. Bitte, dann ist der Jochen zuerst.
Ja, ich
überlege gerade, ob ich irgendwas Pandas-mäßiges
habe, aber
ich fürchte,
nee, ich
was man sich mal
angucken kann, ist
eine Bibliothek namens Al-Khali.
Das ist so ein
Django-ORM-Style-Ding,
aber für
flache
Files und
das ist halt auch ganz nett, wenn man jetzt
irgendwie zum Beispiel
Django kann zum Beispiel und
die OEM da schon
so ein bisschen damit schon so Sachen
gemacht hat, dann kann man halt auch da
auf CSVs oder so
halt Dinge machen, die so ähnlich sind. Also das ist
quasi so die umgekehrte Richtung. Also wahrscheinlich wäre es
praktischer, wenn man Pandas kennt, das halt mit Pandas zu machen,
aber wenn man das nicht kann, dann kann
man halt auch
irgendwie, wenn man Daten als
CSV ausgeschrieben hat oder so, damit
irgendwie wie auf einer Datenbank arbeiten.
Das fand ich ganz witzig, die Idee.
Deswegen würde ich das mal
picken, aber ja.
Ich würde tatsächlich
Pickel nehmen. Ich weiß nicht, hatten wir das schon mal oder so?
Ich fand das total super, dass man da so Preisenobjekte speichern kann.
Stimmt, nee, das hatten wir noch nicht.
Ist auch Teil der Standardbibliothek und
genau, daher muss man nichts zusätzlich installieren.
Das ist super.
Kann man eigentlich auch mit DataFrames machen, oder? Ich weiß jetzt nicht, wie schnell
sowas geht und ob man das nicht lieber in der Datenbank dann speichert.
Doch, kann man mit DataFrames
auch machen. Ist auch tatsächlich ziemlich
schnell. Ist auch, habe ich oft
gemacht. Wenn man keine Lust mehr hat
und wieder anfangen muss, immer an der gleichen Stelle zu debuggen,
dann lädt man einfach dann irgendwann den Pickel ein oder so.
Spart sich immer die Zeit vor dem Ausführen.
Ja.
Also genau, das
ist, nee, das ist tatsächlich,
wenn man, also ich finde,
Data Frames zu pickeln,
es funktioniert
ganz gut. Also man muss vielleicht dazu sagen,
man muss dem Ganzen vertrauen.
Also wenn man,
Wenn einem jemand so ein Pickel-File gibt,
dann sagst du,
wie war das bei der Sesamstraße?
Macht so ein French-Code auf?
Willst du ein Pickel-File von mir
deserialisieren?
Genau. Dann lieber nicht machen, weil
das führt halt beliebigen Code aus.
Das ist vielleicht nicht so schön.
Aber wenn man das selber generiert hat,
dann ist das vielleicht okay.
Dann ist es auch sehr schnell.
da kann man durchaus, also wenn die
I.O. ist, ich habe das nicht an die
Grenzen, oder war da, ne, ich glaube, ich habe das
tatsächlich nicht an die Grenzen
bringen können, sondern das war immer so
schnell, wie halt das Plattensystem drunter war.
Also ich habe damit auch schon,
da ging halt so Gigabyte pro Sekunde
durch. Bei CSV ist
CSV ist richtig langsam. CSV ist halt so
wenn es schnell ist, ein paar Zehn
Megabyte pro Sekunde.
Was halt, wenn du ein paar Gigabyte große Files hast,
dann dauert das.
Und Pickle ist halt so,
selbst wenn die Files Gigabytes groß sind,
kannst du dann das halt, wenn das IOSystem, das du hast, schnell ist,
dann dauert das halt, zwei Sekunden
ist das da. Und
das ist natürlich schon schön. Es gibt
andere Formate für, gerade um Daten,
wie im DataFrame,
man sehr oft hat, irgendwie zu
speichern, HDF5 zum Beispiel, oder Feather,
gibt es da auch eine Library, wo es auch veraltet eigentlich.
Heute würde man eher dann eben
Arrow verwenden und dann ein paar K-Files
lesen und schreiben.
Das ist auch sehr schnell.
ähm, HD5 ist,
geht so, ist ein bisschen,
ist nicht ganz so schnell, aber
ja,
lass mal überlegen, gibt's sonst noch irgendwelche Formate, die
interessant sind? Es gibt dieses NetCDF4,
das ist die Weiterentwicklung von HD5
und, ähm,
da hat man dann... Hier ist die Weiterentwicklung von
5? NetCDF4,
ähm, das ist schon die
vierte Iteration von NetCDF,
aber irgendwann sind die wohl aus HDF
entstanden. Wie das
genau zustande gekommen ist, weiß ich auch nicht.
Die haben dann so Späße, wie man kann direkt File Blobs angeben
und dann über mehrere Files eine Variable öffnen.
Das ist ganz spannend, wenn man sehr große Datensätze als Chunks
auf seiner Festplatte hat.
Aber technische Details dazu weiß ich jetzt auch nicht.
Tja, Tim, hast du noch ein Lieblingsmodul?
Ja, ich habe ja eben schon gesagt, ich mag Plotly unheimlich gerne.
Aber wenn man Plotly-Grafen erstellen möchte,
dann muss man irgendwie so ein ganz tief verschachteltes Data-Dictionary bauen
und dann ein Layout-Dictionary bauen und super viel konfigurieren.
Und Matplotlib geht halt schnell.
Und Plotly hat kürzlich noch ein Tool rausgebracht,
Matplotlib-to-Plotly-Grafen,
wo man, das funktioniert noch nicht perfekt,
aber so die Basis-Grafen wie Boxplots oder Scatterplots
sowas kriegt man damit
in Matplotlib ganz schnell
definiert, irgendwie mit zwei, drei Zeilen
Code und dann mit einer
Zeile konvertiert in Plotligrafen
und dann hat man direkt dieses
Interaktive, man hat
Mouse-Hover und man kann zoomen und
so. Das fand ich ganz schön.
Ist aber noch
in den Kinderschuhen.
Ja, aber schön, das spannend zu verfolgen.
Cool.
Habt ihr noch irgendwas, was ihr loswerden wollt?
irgendwie das zu eurem Modul der Woche oder
sind wir damit durch und
Nö, ich glaube damit. Achso, vielleicht
ja, wollen wir
genau
nächste Woche ist vielleicht ganz interessant,
wenn irgendjemand da ist, der
zuhört, zufällig, aber ich glaube es ist wahrscheinlich
eher nicht so eine Podcast-Konferenz
in Köln. Ja, die Subscribe.
Bei uns genau um die Ecke ist, dachten wir, gehen wir auch mal hin.
Genau, da werdet ihr uns finden.
Genau, da könnte man uns
treffen, wenn man
wollte. Also wer möchte, kann einfach
eine Mail an uns fragen. Das kommt in den
Veranstaltungen. Genau, aber ihr könnt uns ja gerne treffen.
Tatsächlich wissen wir noch nicht genau, ob wir Freitag und Samstag
und Sonntag da sind. Aber
auf jeden Fall am Samstag und am Sonntag wird ihr uns wahrscheinlich
da sehen.
Das besprechen wir noch genauer.
Am nächsten ist ja
immer mal wieder Django zur Sprache
gekommen. Anfang April ist die
DjangoCon in Kopenhagen.
Vom 10. bis zum
14. April ist es, glaube ich.
Sieht man dich da?
Mich nur am 9. April.
Da ist das Django Girls Camp.
Ein Tag Django
lernen.
Da fliege ich kurz hin
als Mentor. Ich habe leider für die Konferenz selber
keine Zeit. Ja, okay, super.
Ja, wolltest du noch was
zu dem Cast sagen, zum Django-Cast,
Jochen, oder machen wir das von anders?
Ja, also da, letztens
gab es irgendwie so ein Mail von Apple,
wo sie gesagt haben,
also wir werden euch jetzt nicht direkt
auslisten irgendwie, aber
ihr solltet dann mal vielleicht irgendwie ein paar Sachen an eurem Feed
ändern, da muss ich jetzt nochmal ran.
Zum Beispiel sowas wie Episoden,
Nummern sollten nicht im Titel sein und so.
Das machen aber alle, ich auch.
Wir können uns weiter nochmal
irgendwas dran tun und genau,
ja, wir machen da auch
so einen kleinen Workshop
irgendwie auf der Subscribe und
da müssen wir auch noch ein bisschen was für tun
und da wäre es natürlich auch interessant, was dann noch so, also
was ich jetzt schon implementiert habe, ist, dass man jetzt nicht mehr
dass ich dann ein JavaScript-Interface brauche,
um irgendwie Audio-Files hochzuladen.
Aber
ja, mal gucken, was da noch so da dazukommt.
Und dann, was super dringend ist,
ist irgendwie, dass die Dokumentation
mal so ein bisschen besser wird und so.
Mal gucken, ob ich die zwei Zeilen zu schraff.
Zumindest so in den First Step oder so.
So in den großen Struggle.
Ja, wenn ihr irgendwie so Anfänger seid wie ich,
dann kommt ihr da bestimmt noch irgendwo dran.
Ja, vielen Dank, dass ihr
zugehört habt heute wieder, dass ihr eingeschaltet habt.
Wie auch immer, wann auch immer, wo auch immer.
lasst uns das übrigens wissen, schreibt
eure E-Mails, Kommentare an
hallo-at-python-podcast.de und
ja, kippt uns
weiter an alle Leute, die Python interessiert, in eurer Nähe,
erzählt euren Freunden, Kommoditonen.
Ja, das kann man vielleicht auch,
was man auch machen kann, ist auf iTunes
bewerten, wenn das irgendwie,
also das hilft natürlich stark,
aber
genau, ansonsten, ja.
Ja, genau.
Sagst Bescheid, erstmal hört uns gerne,
vor allen Dingen wieder und so, bleibt uns gewogen,
wie man so schön sagt.
Und bis zum nächsten Mal. Bis zum nächsten Mal, tschüss.
Vielen Dank für die Einladung, tschüss.