Transkript: PP06 - Pandas

Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python 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 unser Gast, der Simon.

Ja, hallo Simon.

Genau, vielleicht kannst du dich einfach mal kurz vorstellen, dann genau, 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 Biostudium ein bisschen geforscht in der Bioinformatik.

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.

Das Gaming haben wir jetzt 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 da auch ganz viel mit deinen 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, Lob, Kommentare, Hass, dann schreibt uns doch an hallo.pytes-podcast.de.

Ihr findet natürlich die Links und alle zulessen 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 auch noch ein anderes eben zu der Datenbankfolge, dass sie gar nicht so schlimm gewesen wäre mit der Länge.

Und das fand ich auch ganz gut.

Das ist übrigens vielleicht ganz interessant.

Also wenn man sich anguckt, welche Folgen komplett runtergeladen wurden, dann hat die beste Quote tatsächlich die Datenbankfolge zurzeit.

Was ich ein bisschen überraschend finde.

Ich hätte jetzt auch erwartet, dass es eher ein bisschen runter geht, aber.

Vielleicht müssen wir noch mehr so Buzzword-Bingo-Sachen machen und dann ganz viele tolle Klickteilen bekommen.

Nein, der macht 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, ne?

Morgens, abends, nachts, beim Aufstehen im Flugzeug, könnt ihr immer hören.

Ja, bevor wir in das Thema gehen, jetzt weiterhin.

Noch ein paar News aus der Szene.

Und zwar gab es so ein bisschen was Neues, glaube ich.

Python 3.8, zweiter 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.

Ach doch, ja, alles klar.

Das ist ja immer so.

Das ist 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 dann immer so das, oder hat man jetzt immer noch in der stabilen Version, aber vielleicht hat man das mit drei Achter nicht mehr so.

Das Problem, dass man, wenn man jetzt eine Funktion aufrufen möchte, und sag mal so, man startet halt ein Pool von fünf Prozessen oder sowas oder zehn 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, ich 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 machen ganz 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 in, 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 alle die ganze große Bestellung an verschiedenen Kasten abgearbeitet wird, um danach wieder in der richtigen Reihenfolge im Einkaufsgraub zu landen.

So ungefähr.

Ich weiß nicht, ob die Analogie da an der Stelle 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, indem man das jetzt aufteilt und mit jedem Einkaufswagen einzeln zu einer Kasse.

Und 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 es ist 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 seralisiert 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 sie wenig Hauptspeicher, ist ja auch blöd.

Und was halt schon immer 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 hat.

Shared Memory, ein geteilter Einkaufswagen, fährt mir jetzt auch tatsächlich so.

Es 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 Ruhre von Kassen.

Die Kasse ist oben, unten, rechts und links, aber man kann einfach eingreifen.

Das ist schön, ja.

Genau, so könnte man sich das vorstellen.

Und das heißt, man hat halt, selbst wenn man, wenn man jetzt Daten hat, die so gerade in den Hauptsprecher 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 die jetzt in 3 abkommt.

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 konnte ja auch einfach Chatmemerie reservieren, da Dinge reinpacken.

Also da gibt es übrigens auch ein schönes Modul in der Standardbibliothek, das heißt 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 so groß waren, dass man da nicht einfach irgendwas mit tun konnte.

Das heißt, man hat halt irgendwie einen Chat-Memory-Bereich, in den schreibt man halt irgendwie mit per Struct irgendwie sozusagen C-Struct-Daten irgendwie rein und hat halt halt Prozesse, die wiederum einen Pointer auf diese Chat-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.

Ich hört ja auch gerade diese Hintergrundmusik, das ist so ein bisschen wie in Battlestar Galactica, ne?

Diese.

Guck mal, kleine Oblinie.

Ja, die nächsten News aus der Szene, doppelte Keys, gab es einen Post von Guido irgendwo, der hat irgendwas geschert?

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 Dikt A plus Dikt B.

Und dann werden sozusagen die Keys hinzugefügt oder halt wird das eine, werden halt die Keys, die in einem einen Ding drin sind, entfernt und man das halt abzieht.

Und das ist natürlich auch eine ganz, also es ist eigentlich relativ naheliegend.

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, irgendwie, der hat zweimal den Key irgendwie draus zugewiesen und dann quasi ein Dictionary mit zwei identischen Keys erzeugt, wo dann nur einer von überlebt hat.

Äh, ja.

Irgendwie so, also wenn man halt, ich glaube, welches 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.

Wenn ich das richtig verstanden habe.

Genau, das war das Verhalten, was mich irgendwie gewundert hat, aber das ist, das ist, das ist generell so, das war schon immer so, offenbar.

Wenn man halt, äh, also insofern ist es halt kompatibel mit diesem Verhalten, dass wenn man jetzt irgendwie ein Key mehrfach an 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 Pair

oder sowas.

Nein, nein, es wird einfach das Letzte genommen.

Und da hat er halt dazu, oder Frau Menning zu geschrieben, dass ja, er hat damals lange darüber nachgedacht, dass er, weil irgendjemand die Frage gestellt hat, ob das Absicht wäre oder nicht.

Er meinte so, ich habe damals lange darüber nachgedacht und es ist Absicht.

Ich erinnere mich an ein Programm, wo ich das dachte, wo ich irgendwie komischen Fehler hatte und das, glaube ich, genau daran gelegen hat, weil ja irgendwelche Duplikate dann zwar drin waren, ich habe es aber nicht gemerkt habe, erst irgendwann später, als mir um die oben 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.

Dieses 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 und hat er so das als Beispiel quasi, wenn man jetzt mathematische, also arithmetische Geschichten halt nicht als Operatoren hätte, sondern wenn man da Funktionen 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 Operatoren, äh, 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, das einem sagt, was da, was da passiert.

Und daher sind für so arithmetische Geschichten, um zu sehen, was da passiert, ist es halt viel sinnvoller, das mit Operatoren schreibweise hinzuschreiben als mit Funktionen, was man ja auch tun könnte.

Und für Dicks ist es 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, einen 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 sich um 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, es war auch so, dass da irgendwie eine ganze Menge Überschneidung war zu dem, was wir in unserer Djungo-Folge irgendwie erzählt haben, so von dem Rundtenor.

Ich hatte gerade, ich habe ihn auch gehört, ich bin begeistert.

Ja.

Gefällt mir sehr gut.

Also es ist wirklich toll.

Jetzt kam noch eine zweite Folge, es war so eine kurze Folge dazu.

Fünf Minuten.

Könnt ihr mal sehen, wie man den Kürze die Wörter 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 es noch einen anderen Powted Pattern out louder, aber da muss man 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 neugericht natürlich.

Ja, ich würde sagen, am Ende stellen wir nochmal so ein bisschen die Picks der Woche, der Woche, des Monats vor.

Aber wir sind, glaube ich, mittlerweile so weit, dass wir so ein bisschen jetzt was.

Ja, wir können eigentlich mal erzählen.

Ja, Pandas, was ist das denn überhaupt?

Also beim Eishockey, ich bin ja Eishockeyfinder, haben die Schiedsrichter jetzt so ein Panda-Symbol 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, manchmal so, aber Pandas und Spendaffä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, als wir drüber gesprochen haben, ob wir nicht irgendwie mal zusammen irgendwie 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 Framework, sondern auch Python Pandas 3D, die Game Engine.

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ß ich nicht, fünf Minuten aneinander vorbeigeredet.

Wir können doch jetzt gerne noch mal fünf Minuten über die Game Engine, Pandas 3D reden, wie du magst.

Ist sie 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.

Also 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 Cute oder sowas?

Ich sage es mal vorsichtig, ja, damit kann man Spiele machen.

Mit Pi Game 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 AAA-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.

Das war Unreal.

Unreal Unit U3D und

Cry Engine.

Ja, okay.

Craig ist ja nicht frei, it7 oder so acht.

Weiß ich gerade gar nicht.

Ich glaube, wir sind gerade völlig off-Topic.

Wir wollten über Pandas.

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 Mammutfolge mit wie lange drei Stunden haben wir gebraucht?

Ja, ein bisschen mehr.

Aber genau, um eine Dreh.

Wenn ihr mal wieder die Wohnung richtig putzen wollt, dann was euch 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 das große, 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 Pearl gemacht.

Und was man in Pearl 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übergewechselt.

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 erstmal dazu, dass die Daten nicht mehr so strukturiert sind, wie man das eigentlich dachte in einer 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.

Das muss man jede einzelne Teile 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.

So, und dieser erste Schritt, überhaupt die Daten erstmal maschinenlesbar zu kriegen, der ist im Wesentlichen unabhängig von der Analyse.

Aber nochmal für unsere Ganzanfänger nochmal bitte erkennen, 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 einen 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, genau.

Und was häufig passiert, ist, wenn Menschen Tabellen ausfüllen, um die visuell ansprechend zu machen, verletzen die ein wichtiges Kriterium, das 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, die nicht voneinander getrennt sind.

Dann stehen zum Beispiel sowas wie eine Spalte, wo zwei verschiedene Datensachen auf einmal drinstehen.

Genau.

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 halt quasi bei Datenbanken wäre das halt die erste Normalform, dass halt man in einer Spalte immer nur einen Wert stehen hat und nicht irgendwie mehrere zum Beispiel, was halt dann manche Leute dafür hat.

Also Fahrenheit und Zeltus wäre okay, wenn man die

Wenn die Spalte, wenn das.

Wenn die Mission enthalten wäre in der Zelle, ob es Celtus-Erfahrenheit wäre.

Weil das wäre sonst problematisch, wenn man irgendwie.

Ja, also wir kommen da sicherlich gleich nochmal zu, so gut das geht, in einem Podcast Tabellen zu beschreiben.

Ja, wir versuchen, dass das so organisieren.

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.

Die Probleme höre ich, fangen dann an, wenn man keine zweidimensionalen Tabellen mehr hat, keine, die man mal eben so auf seinem Whiteboard malen kann.

Welche, die man bauen müsste oder wo man irgendwelche Dimensionen verbraucht, die wir uns jetzt nicht so räumlich vorstehen können.

Genau.

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, wenn du jetzt diese.

Ich hab 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 1 weiter draußen so ein bisschen das, was darauf aufbaut.

Das war dann Pandas, das war Stats Models, war das, glaube ich.

Achso, für Zeitreihen und

so weiter.

Genau.

Und C-Born.

Und das waren dann die Pendants.

Also CBON auch wieder zur Visualisierung und Stats Models 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 das Bärminimum, 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

das Problem?

Also ich würde sagen, dass auch das, denke ich, Hauptfeature von Pandas ist, dass man damit die Daten überhaupt erstmal irgendwie in so ein reinbekommt irgendwie.

Also Wesmerkin hat das auch mal gesagt, dass die populärste und wichtigste Methode, die die Pandas halt hat, ist halt ReCSV, 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 gepasst.

Und das heißt, ja, egal wie komisch die Daten aussehen, die man so hat, man kriegt sie irgendwie mit Read CSV 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 so.

Pandas hat also vorbereitete Funktion für weiß nicht eine Zeitreihen-Analyse 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 wie 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 Pannas auch besonders gut kann, sind halt so Zeitreihen-Geschichten.

Aber man kann auch diverse andere Dinge damit machen.

Und 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, 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 man sich anguckt, wie viel Geld wird halt eigentlich ausgegeben für Open Source Entwicklungen.

Also 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, wenig, bekommt eigentlich wenig Ressourcen, da gibt es wenig Geld, da gibt es wenig Leute, die hauptberuflich dran arbeiten.

Und die Projekte, die am meisten Geld bekommen, sind sowas wie Tensorflow oder so, weil man drüber schreiben kann, inwiefern das halt noch Open Source ist, aber.

Und auch die ganzen Cloud-Dienste oder so, die haben alle irgendwie Methoden, Daten da reinzubekommen, Daten wieder rauszubekommen.

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 Daten-Import-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-Tensor-Flow-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, weiß manken, ihr erzählt davon halt auch immer, dass er 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, da muss man doch, 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, 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 in irgendwie ein Format bringen muss vorher und vielleicht aufräumen muss, sauber machen muss.

Da gibt es auch 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 ist 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.

Was, 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, äh, hier ist kein Wert, äh, Wert von NumPy.

Das ist auch irgendwie sozusagen ganz unten drunter, ist das tatsächlich ein Float kann man das halt ausdrücken und ja, das hat halt auch so 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.

Das war 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 oder man hat halt gesagt, okay, da kommt irgendwie was dazu, was halt irgendwie fehlt oder so und man macht einen Re-Index und guckt, dann hat sich plötzlich der Typ der Spalte in Float geändert, weil es halt keine fehlenden Werte in Integer-Typ, äh, die Type-Spalten gibt.

Und das ist ein, das ist ein ziemlich blödes Problem.

Aber jetzt gibt es halt irgendwie seit einiger Zeit diese Array-Extensions, äh, äh, Array-A-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 die, am Ende Ende Januar ist die letzte größere Release von Pandas erschienen, ich glaube 0.24 oder so.

024, ja.

Und da ist jetzt halt auch ein native, natives Integer-Spaltenformat drin, das halt auch nunnen kann.

Und das ist natürlich total cool irgendwie.

Und man kann jetzt für, also da ist man jetzt, 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, dann würde das Code brechen und dann, also wäre keine abwärtskompatiblen Änderungen mehr.

Und das ist natürlich alles so ein bisschen blöde Situation.

Aber irgendwie mit dieser Array-Extension-AP 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 das 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 keinen 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, um da.

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 Date Time mit Time-Zonen dran und so.

Das ging vorher auch nicht.

Und das ist.

Oh, also sowas wie Grad mit Celsius-Erfahrenheit vielleicht.

Das ist nochmal ein anderes Ding, genau, dass man, das möchte man auch gerne haben.

Ich weiß nicht, ich glaube, das ist nicht direkt in Panas 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 mitunter 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 denn aus, dass man eine Spalte ein Tupel drin?

Da gibt es im Prinzip irgendwie so eine Tabelle von Metadaten, wo drin steht, welche Spalten, welche Maßeinheit, welche Skalierungsfaktoren haben, wann die zuletzt bearbeitet wurden.

Und darunter stehen dann sehr realisiert die Daten drin.

Und dadurch hat man sehr, sehr schnellen sequentiellen Zugriff auf seine Daten, hat aber trotzdem die Möglichkeit, diese Skalierungen 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 ist.

Es gibt eine Bibliothek für so Maß-Einheiten und sowas.

Ich weiß aber nicht genau, wie das gemacht ist.

Müssen wir 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 dazugeschrieben.

Ja, also genau, das eigentlich, so wie früher, oder der Default ist immer noch bei Pandas, dass 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 Data Frame, dass jede Spalte irgendwie ein 1D, also ein eindimensionales NumPy-Array ist.

Aber das ist halt nicht so, sondern ein Data Frame besteht aus Blocks von 2D NumPy-Arrays, jeweils zu einem, also unterteilt nach Datentyp.

Also wenn ich jetzt sozusagen habe einen Data Frame, 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, ja, genau.

Das ist halt, eigentlich sollte das egal sein, wenn man sich, ne, sollte man sich eigentlich keine Gedanken drü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 es ist halt nicht, 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 Data Frame, dann hat man das Problem, dass dadurch, dass jetzt, wenn man schon ein paar Floatspalten 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 gesagt haben, wenn man da irgendwie viele Spalten hinzufügt, dann immer erstmal die einzelnen Spalten sammeln und dann hinterher alle zusammenfügen oder so und nicht irgendwie auf einem großen Data Frame eine Spalte hinzufügen, dann noch einer hinzufügen, das ist schlecht.

Und das sollte eigentlich natürlich, das sind also so Schwächen, weil 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 würde.

Oder dass es jetzt, also mit dieser Version, 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, ach, das ist vielleicht auch noch interessant.

Also Panas 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 fünf oder vielleicht sogar bis zu Zehnfacher der Datenmenge, die tatsächlich auf der Platte landet oder so, man als Hauptspeicher braucht, weil man kopiert ein paar, aber man fügt ein paar Spalten hinzu, transformiert ein bisschen was und dann schon hat man irgendwie einen fünffachen Haupts

peicher verbraucht.

Und daher ist es halt nicht so richtig effizient.

Kann auch sein, dass es jetzt dann halt besser wird.

Aber 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.

So dass man halt oft dann nicht ein paar Sekunden warten muss, sondern eigentlich immer nur so ein paar hundert Millisekunden.

Und dass gerade wenn man das jetzt zusammen 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, man sieht ein Ergebnis und kann damit direkt weiterarbeiten.

Genau.

Ja.

Ja, nur vielleicht noch mal kurz ein Jupyter Notebooks, also ein tolles Tool tatsächlich, wenn man sich so gerade so Daten aus der Wissenschaft angucken will, einfach ein Data-Frame laden, da die ganzen Daten reinkloppen und dann mit MarklopDip und C-Born irgendwo direkt live immer Anderungen 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

auf den Data Frame-Levelmaß, auf dem Datenschutz.

Dann kriegt man direkt alle statistischen Auswertungskennzahlen, die man so kennt.

Dot 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 Data Frames 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 spricht sollte.

Es können gut sein, dass es funktioniert.

Also kann man sich halt auch ganz kleine Datenschunks, kleine Tabellen direkt aus der Zwischenablage in sein Dataframe reinladen.

Das heißt, wenn wir jetzt so von diesen Gigabyte-Bereich liegen, ich glaube, für wissenschaftliche Anwendung müsste das in den meisten Fällen auch 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, aber stimmt, wir hatten eben noch gar nicht, genau, vielleicht sollten wir da so ein bisschen systematisch auch nochmal kurz rangehen, was, also Panas, genau, das hat auch was damit zu tun, wo der Name herkommt.

Also Panas steht eigentlich für Panel Data oder das war halt auch immer das, was halt so in dieser Finanzwelt, wo du Leute von geredet haben von Panel Data.

Und dann meinten sie dann halt oft Excel-Sheets irgendwie oder mehrere davon.

Und das kann Panas 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.

Series 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 Leute auch gerade, ob sie das irgendwie wieder rausnehmen, weil es eigentlich ziemlich sinnlos ist und der Hauptnutzen irgendwie bei den Data Frames ist.

Ja.

Genau, daher kommt der Name.

Es ist ein bisschen wie blöd, ne?

Wenn man danach googeln will und dann hat man Tierbilder.

Aber wir haben immer wieder Tierbilder dabei.

Das Vorbild für Pandas ist ja R, denke ich mal.

Das ist mit Googlen auch nicht viel einfacher, aber genau, ja, was, ich weiß nicht, du hast auch schon mal mit A gearbeitet, Simon.

Was sind denn da so die, ja, wie kann man das eigentlich miteinander vergleichen?

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 Dataframes 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 kein 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 Data Frames grundsätzlich auch Typen je Spalte.

Das ist in Excel nicht so.

Da hat jede Zelle im Prinzip einen Typ, wenn man will.

Da kann man auch ganz viel bösen Schabernack mit treiben.

Und in Data Frames, 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, ah, Beispiele.

Blau, rot, gelb als Farben in einer Spalte.

Dass die in dem zugrunde geliegenden Datenformat erstmal 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, ähm also in Pandas heißen die Dinger Categorials und das wurde dann quasi intern irgendwie auf Integers wurde das abgebildet.

Man hatte die einfach durchnummeriert und dann war das halt, was halt natürlich auch viel weniger Platz braucht als Text, aber ja genau.

Aber jetzt auch, glaube ich, mit der neuen 024 ist es jetzt so, das 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 Intelligenz-Geschichten irgendwie verknuselt.

Und ja, alles 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 Zahlen.

Praktisch.

Wie schaut man sich denn so Daten dann an?

Also ich musste dir ja irgendwie eine Struktur bringen.

Ich habe jetzt irgendwie ganz viele Spalten irgendwie in meinem 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, ist, man kann sagen, also Data Frame, man kürzt es normalerweise mal 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 dir 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 Mattplot-Lib.

Aber man kann halt das auch das Plotting-Backend von Panda sozusagen austauschen.

Das ist halt also Pluggable und man kann das austauschen.

Und man kann halt auch Bouquet zum Beispiel nehmen oder weiß gar nicht, ob es doch noch viele andere.

Ich habe Plotly schon gesehen in dem Zusammenhang und C-Born ist ja im Prinzip Mattplot-Lib nochmal ein bisschen erweitert, kann man da auch reinpluggen.

Genau, sodass es halt, man hat halt immer, man kann es dann anders aussehen lassen.

So dass zum Beispiel bei Bouquet oder Plotly ist es halt so, wenn man dann sagt, DF-Plot irgendwas, dann kann man das, dann ist halt, ist das, was man sieht, dann halt auch scrollbar zum Beispiel, man kann da drin zoomen oder so, was man bei einem Matplot-Lib-Bild jetzt nicht machen kann, weil da ist einfach, das ist quasi dann halt so ein schadisch rausgerändertes 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 Potly oder so hat man dann, kann man, wenn man reinsubt, sieht man einfach an der Stelle mehr.

Und man muss an den Plottaufruf 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 grupiere ich denn da irgendwas von den Daten, wenn ich ja so ganz viele Spalten und Zeilen habe?

Also wenn man gar nicht weiß, wie man anfangen soll, wenn ich mich richtig erinnere, macht Plot standardmäßig einfach einen Perplot.

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 in

der ideellen Welt, wo es gibt.

Gibt es im Vorfeld eine Fragestellung und dann kann man auf diese Fragestellungen 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 Data Frame-Objekt per Dot-Syntax den Spaltennamen an.

Oder in eckigen Klammern wie bei einem Listenzugriff.

Das muss ich gerade genau überlegen.

Doch, da geht der Spaltenname auch.

Ja, es gibt zwei Interface, 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-Lock, 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 Group by irgendwie so vorsortiert oder sowas?

Und dann gibt es irgendwelche Alternativen, dann kann man die in Beziehung setzen und dann alles plotten, was man macht.

Also erstmal 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 das ein Group by.

Es gibt auch Funktionen, um eine kumulative Summe über irgendeinen Datensatz direkt per Funktion aufzurufen.

Das ist was, was man auch einfach plotten möchte.

Dass man sagt, okay, ich habe jetzt hier meine Daten und ich plotte dahinter in der zweiten Serie auch noch die kumulative Summe.

Dann ist das quasi per einzelnem Funktionsaufruf in Pandas möglich.

Spannend für die ganze Anwendung, wenn man irgendwie so kategorisierbare Daten, verschiedene 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 70 Kilo und welche Wahrscheinlichkeit haben die für bestimmte Dinge im Kinder.

Genau, da kommen wir in einen anderen Bereich so ein bisschen rein und das ist Indizierung auf Basis von Bool's 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 entsprechenden einen Slice aus meinem Data Frame rausgeben, der nur dieser Bedingungen entspricht.

Was wird denn der technischer Zeug?

Also macht er eine Kopie der Tabelle mit diesen Werten oder setzt er halt dann noch eine neue Tabelle daneben mit so Boolean-Werten ist wahr, ist falsch oder und macht dadurch so irgendwie so einen Index, den er nur liest?

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, so eine DF-Eckige Klammer auf, irgendwie DF.Size größer irgendwas und dann und DF-Size kleiner irgendwas.

Dieser bullshit-Ausdruck wird sozusagen dann halt irgendwie in eine Spalte verwandelt, halt, 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, raus werden halt rausgesucht und alle anderen werden halt ignoriert quasi.

Und ja, ganz genau wie das technisch drunter funktioniert, weiß ich jetzt aber auch nicht.

Und ja, das sind halt so, ich kann mir vorstellen, dass irgendwie so ein NumPy halt 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öne Methode, um da halt irgendwie Sachen rauszuselecten.

Vielleicht kann man an der Stelle auch mal gerade eine Blogartikelreihe erwähnen, das fällt mir ja gerade ein, die ich immer wieder, wenn ich irgendwie Leuten von Pandas erzähle, auch miterwähne, weil die so toll ist.

Das von Tom Augsburger Blogartikelreihe, muss ich mal sagen.

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.

So lernt man immer dazu.

Genau.

Und der beschreibt halt sehr ausführlich, wie das mit diesem Indexing halt, ja, also aus Userperspektive, 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 mehrdimensionale 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 doch 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 Panda-Serie ist halt eine, wo man das sehr, sehr schön sehen kann, wie das funktioniert.

Da werden halt eben diese, also im ersten Artikel werden, glaube ich, da irgendwie so halt diverse Indizes-Geschichten erklärt und dann gibt es halt einen Artikel nur zu Method Chaining und ja, dann einen zu Indizes und da wird dann halt nochmal das alte Interface gezeigt und dann halt, was man jetzt mit dem neuen Interface an Dingen machen kann.

Und da gibt es halt wirklich verrückte Abfragen, die man also.

Also das Ding auf jeden Fall ist wieder super spannend, was der neueste Heizescheiß.

Also was ich jetzt da gekannt habe, es wird auch nur 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 Wanderplas.

Da wird auch ein schönes Artikel zu Pandas drin.

Das ist auch frei irgendwo bei GitHub.

Ja, die Notebooks, ähm, unzoger

als Notebooks, die alle verwirklicht hat.

Der 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, dass man direkt da mit Pandaspotten kann.

Ich glaube über den Untergang der Titanic oder sowas.

Ah ja.

Ja, sonst benutzen die Tutorials oft gerne den Iris-Datensatz.

Da geht es irgendwie um Blütenlänge und Breite.

Das war mir immer ein bisschen sympathischer als Biologe.

Als welche Klassen jetzt wie oder welche, wie viele Frauen, Männer und wie viele Jungs und Kinder untergegangen sind, wie viel nicht, also wie viel.

Das ist auch super spannend mit diesen Multilevel-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.

Sonst gibt es da einen Fehler.

Ich weiß gar nicht, ob der da mit NA auffüllt oder ob der.

Ja, gar nichts, müsst ihr ausprobieren.

Außer dass ein Fehler wirft.

Ich weiß es aber auch nicht.

Es gibt da irgendwie so eine andere Funktion, ich weiß jetzt nicht, bei was es genau geht, wenn man halt so ein Data-Frame über so einen NumPy-Array hat oder sowas, dass der automatisch neue Spalten erzeugen kann, die er dann irgendwie fortsetzt.

Habe ich irgendwie kurz entdeckt.

Wenn man einfach eine neue Spalte erstellt, dann, wenn man schon drei oder vier hat, dass er dann, wenn du die fünfte erstellst, einfach dann neue Werte reinbaut.

Kann sein, was ich nicht so gut.

Okay, vielleicht habe ich auch wieder irgendwelchen Quatsch erzählt.

Ich weiß nicht, ob ich 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.

Man kriegt ja immer den gut gemeinten Ratschlag, guckt doch mal ins Handbuch.

Das Pandashandbuch ist tatsächlich länglich.

Also es hat 2900 irgendwas Seiten.

Davon sind rund 900 so die Basisfunktionen, 1400 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 Table of Contents, Inhaltsverzeichnis, genau.

Verlinktes Inhaltsverzeichnis, man kommt schnell dahin.

Ja, die Dokumentation von Panners ist auch sehr gut, ist aber auch manchmal, also die ist schon etwas trocken, also manchmal muss man sich schon so ein bisschen quälen, um dann.

Vielleicht liegt das an dem Tabellenthema.

Könnte auch vielleicht liegt es einfach am Thema.

Sollte man vielleicht eher irgendwie Schreiner werden oder so.

Ja, das überlege ich mir manchmal.

Das wäre toll.

Ja, aber genau, ja, ja, stimmt.

Was hatten wir?

Was gibt es für Datentypen, so in 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 zwar auch relativ kurz.

Also wenn jetzt mit einer Datenbank arbeitet und da SQL-Statements schreibt, 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 ja einen Aufruf Merge oder so.

Aber im Grunde macht es dann halt auch einen Join zwischen zwei Dataframes.

Dann kann man angeben, auf welchen Spalten gejoint werden soll und solche Dinge.

Und genau, eben all diese Group-By-Geschichten.

Es gibt tatsächlich so eine Funktion, wie man eine Datenbank in DataFrame bekommt und andersrum, wie man eine Dataframe, wie man irgendeinen Datenbanktypen speichert.

Ja, ja.

Also für alle Datenbanken gibt es da Adapter, mit denen man die Daten rauslesen kann.

Genau, also diese Import-Export-Geschichten.

Also wir haben nur über Import geschrieben, aber gesprochen, aber Export gibt es halt auch für alle diese Datentypen.

Warum schreibt dann irgendjemand noch SQL Statements?

Ja, doch, also manchmal kann schon sinnvoll durchaus sinnvoll sein.

Also wenn du in der Datenbank ja auch irgendwas manipulieren willst an Werten, dann musst du es ja tun.

Du kannst ja gar nicht.

Kannst du auch in Pandas machen, aber dann hast du das Problem, du musst ja irgendwo wieder zurück in die Datenbank schreiben.

Man klöscht eine neue Datenbank.

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 Data Frames.

Ich verwechsle es auch immer wieder, deswegen habe ich gerade mal kurz nachgeguckt.

Und es gibt noch Concatenate, da kann man aus einem Data Frame irgendwie Spalten in ein anderes reinziehen.

Ja.

Ja, und dann genau, solche, eben, es gibt als so Datenmanipulationsgeschichten, eben Join-Merch, dann gibt es noch solche Sachen wie, genau, das ist auch schwer zu erklären, wenn man das jetzt nur hört, fürchte ich.

Sowas wie Pivot, Unpivot, Meld, Stack Unstack.

Das sind ja praktische Geschichten, aber ich weiß jetzt ehrlich gesagt nicht genau, wie ich das.

Ja, du kannst, also wenn du, okay, ich versuch's 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 verwechseln.

Das ist relativ einfach, aber Pivot macht schon so ein bisschen kompliziertere Dinge.

Das aggregiert irgendwas zur besseren Auswertung.

Nein, 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 der Zeile stehen, die möchte man als Spalte haben, um dann halt die Spalte besser plotten zu können.

Und dafür verwendet man dann auf Pivot.

Und dann, genau, die umgekehrte Funktion dazu ist Meld.

Und die aber eigentlich noch allgemeineren Funktionen, die funktionieren dann eben auf so Multilevel-Inder indizes sind halt Stack und Unstack.

Aber das kann auch sehr schnell so ein bisschen überfordern.

Also ich kann sagen, so aus dem Biologenalltag, dass ich Pivot und Meld 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 weiß ich nicht, ein.

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 einer 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.

So dass ich wegkomme von ich habe im Prinzip zwei Zeilen, die jeweils vier Unterzeilen beinhalten, zu 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 Anstacken, 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 Unstack oder so Thema halt auch einen Modern Pandas-Artikel gibt.

Ich fürchte nein.

Schade.

Ah ja, muss man einfach mal nach.

Also, naja, wir verlinken 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 dann damit dann tut.

Ja.

Ja, vielleicht nochmal dieser Pivot kurz, das wart ihr gerade kurz dabei, da sind wir kurz abgeschreift.

Also was macht man damit jetzt genau?

Also, kennen das irgendwie jetzt irgendwie aus Excel, dass man irgendeine Auswertung hat.

Man hat dann irgendwelche Datenblätter oder sowas und da möchte man dann irgendwelche Aggregate irgendeinem Endnutzer auf einem Auswertungsdashboard zur Verfügung stellen.

Und da wird dann irgendwas zusammengerechnet.

Ja, Excel genau kann ja auch sowas für Pivot-Tabellen machen.

Ja, also ich habe hier gerade mal das Data Science Cheat Sheet Pandas offen.

Die 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, die anhand von einer Spalte gruppiert und dann aber über andere Spalten eine Funktion aufruft.

Das kann zum Beispiel sowas sein wie ein 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 einen Hintergrund in R haben, da gibt es T-Apply und L-Appply für Zeilenspalten und was weiß ich nicht alles.

In Pandas Data Frames 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 es geht schon, ist halt nur dann sehr, sehr langsam.

Während halt, wenn man jetzt Apply aufruft, dann ist es halt ziemlich schnell.

Weil unten drunter, weil eben, also 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 Vortrag-Bibliotheken, die unten drunter unter der NAMPA liegen.

Und es ist halt auch so, dass es dann in gewisser Weise schon parallelisiert wird.

Oder halt diese, diese, ich weiß jetzt gar nicht, wofür SIM-D steht, diese Instruktionssets, diese.

Single Instruction, Multiple Data.

Ah, okay, ja, genau.

Super.

Dankeschön.

Ja, man spricht ja auch von Vektorisierung.

Also man kann halt mit einem Takt-Zyklus halt mehrere Operationen oder 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 einen Integer hat, vier 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 einen Jupiter-Notebook, das sieht dann halt so aus, als hätte man so super, 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 man, wenn jemand da hingehen würde, würde es ein 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, man muss halt auch so ein bisschen eine komische Syntax dafür halt in Kauf nehmen.

Man kann halt nicht mehr Forloops machen, man muss halt immer Apply schreiben und dann halt eine Funktion übergeben.

Oft übergibt man dann halt so anonyme Funktionen, schaut dann Apply und dann Lambda X und dann kriegt man halt irgendwie Wert übergeben, macht dann damit irgendwas.

Ja.

Comprehensions oder sowas kann man auch vergessen, genau, dasselbe Probleme.

Genau, das geht alles nicht mehr.

Man schreibt halt alles nur noch ja quasi, ja, 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, und dann chaint man halt die Sachen hintereinander.

Man kann halt, dann 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 Taktikfrequenzen 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 ja bestimmt Kompiler, 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, die macht einfach nur C gleich A plus B.

Wobei jetzt C, A und B sind halt Vektoren der gleichen Länge.

Naja, C ist der, der erzeugt wird.

Und man macht halt einfach Vorloop, die das tut, dann denkt man sich jetzt, könnte doch eigentlich der Prozessor, der Compiler hingehen und das irgendwie in diese Single Instruction Multiple Data Prozessor-Befehle umwandeln und dann irgendwie das deutlich schneller machen.

Schellst du die raus und nah, kann er nicht, weil in C ängt es halt die Semantik von deinem Programm.

Weil es könnte ja auch sein, dass dieses C irgend 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 Vorloop 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, hat das, ist das die Programmlogik, dass das so sein muss.

So, das heißt, sowas Simples geht schon nicht.

Also man kann natürlich irgendwie dann so Hinweise an den Compiler dazu schreiben, dass 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 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.

Das C kann nicht irgendwie wieder zu A oder zu B gehören.

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 fortan ist.

Auf der anderen Seite, es müsste nicht unbedingt.

Du kannst auch ein C machen oder ein C<unk>, wenn du das halt dem Compiler entsprechende Hinweise gibst.

Aber es ist alles irgendwie nicht so ganz einfach.

Und ja.

Wahrscheinlich will man sich da auch nicht mit rumschlagen.

Aber wenn man einfach so Pannas verwendet, dann passiert das ja alles automatisch und man halt nichts damit zu tun.

Das ist gut.

Ja, genau.

Vektorisierung hatten wir dann.

Genau, was wir vielleicht nochmal ein bisschen detaillierter ansprechen können, ist irgendwie das Plotting.

Also es gibt für jedes Data Frame erstmal ein Dot-Plot 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.

Welche präferiert ihr von diesen Plotting-Bibliotheken?

Also jetzt irgendwie Matplot mit C-Born oder dann doch Bookie oder?

Ich verwende meistens C-Born tatsächlich in Notebooks, aber es kommt halt drauf an, auf den Einsatzzweck.

Also meistens reicht mir das, meistens müssen die für mich nicht interaktiv sein und dann verwende ich halt C-Born, weil es einfach netter aussieht als Matplotlib direkt zu verwenden und das ist halt auch irgendwie einfacher.

Es gibt halt manche Plots, da das geht auch mit Matplotlib, aber es ist halt schon so ein bisschen, also ehrlich gesagt, ich mache das meistens so, dass ich auf C-Born, auf der C-Born-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 ButtplotLib hingehen würde und das so nachbauen würde, dann ist das halt deutlich schwieriger.

Und es geht natürlich auch, Matplotlip ist C-Born baut ja drauf auf, und Buttplot-Lib ist sehr mächtig, aber die AP ist nicht so ganz einfach.

Und eigentlich musste ich da nie, da ich auch nie so wirklich komplizierte Visualisierungen mache, muss ich da nie so tief einsteigen, dass ich das irgendwie wirklich gebraucht hätte, sondern für mich reicht C-Born 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 es eher sowas wie Bokeh oder Plotly das, was man da verwenden möchte.

Also gerade wenn man jetzt, 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, man zeigt 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 irgendwie den Bereich, der sie interessiert, halt irgendwie auswählen und da ranzoomen 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 D3.js, das ist eine Visualisierungslibrary in JavaScript.

Und das hat super viele Funktionen, aber ich benutze das hauptsächlich dafür, dass man einen Maus-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 GitHub-Projekt, 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 was auch für R?

Ja, ja, ja.

Man muss gerade sagen, Dash ist halt so ein Nachbau von etwas, was halt in A super populär ist und in A 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 die das schon, ob sie da dran sind, aber man hört immer noch, dass viele Leute sagen, so, ah, aber Shiny ist schon irgendwie toll 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.

Also 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.

Da, also das ist so eine Koevolution der beiden der beiden Analyse-Workflows, sage ich mal.

Wobei man sagen muss, dass die ursprüngliche Idee für diese Notebook-Geschichte, das kommt aus Mathematiker und gibt es schon ganz lang.

Aber es nie, hat sich nie so wirklich durchgesetzt, bis dann jemand als, äh eben, bis Leute, das dann halt irgendwie dieses Jupyter-Projekt, aus das aus dem iPython-Interpreter halt irgendwie rausgewachsen ist, bis das da implementiert wurde.

Und ich habe jetzt auch letztens gehört, dass jemand Steven Wolfram, 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 die Idee war ja vorher schon da, aber ist unbekannt geblieben.

Und ja, Steven Wolfram hatte darauf gegeben, 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 gehabt.

Es wurde halt alles irgendwie auf Idees und die VD ist irgendwie, tja.

Ja, also manchmal, es ist komisch, ne?

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 schon ganz lange, aber die Umstände waren halt nicht richtig, sodass sie halt vorher halt noch nicht abheben konnte.

Und das ist bei diesen Jupyter-Notebooks ist das halt schon so.

Ich denke, das war halt genau der richtige Moment und jetzt ist es halt groß geworden.

Und ja.

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 Cborn 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 geraden Gleichung 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 Stats-Models gibt es die Funktion OLS, um diese Formeln abzubilden.

Die kann man dann auch mit Pandas Data Frames zusammen benutzen, um wieder Plotting zu machen.

OLS meinte Optimal Linear Squares Modeling, oder?

Müsste ja.

Ordinary Linear.

Ordinary Linear Square

Squares oder sowas?

Ich weiß nicht mehr.

Keine Ahnung.

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 Data Frame 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 2900 Seiten des Pandas-Handbuch 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 2900 Seiten Handbuch gelesen habt, dann sagt mal Bescheid und schreibt uns eine E-Mail.

Ja, genau.

Was Zeitreihenmodellierungsgeschichten angeht, aber habe ich noch nie so wirklich viel mit gemacht.

Ich bin eher so bei Cycit Learn zu Hause und also Machine Learning Bibliothek und auch da ist es so, also meistens, bevor man halt irgendwelche Daten, bevor man Daten irgendwie in Modelle kitten kann, muss man die halt mit Pannas 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, weiß ich nicht, ob die letzte oder vorletzte Version von Cycle Learn war auch kein Problem mehr, weil man jetzt automatisch auch, weil man jetzt auch nicht, weil früher brauchten die ganzen, also in Cycle Learn heißen die Dinger Estimators, Estimator-API, die haben halt NumPy-Arrays genommen und jetzt mittlerweile nehmen die halt auch Pandas Data Frames und die Spaltenname erhalten und wenn man halt irgendwie hintergucken möchte, okay, was ist denn jetzt wo gelandet und so

und dann kann man da auch mit den Spaltennamen 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.

Das ist ein großes Data Science-Ökosystem mittlerweile und das ist halt schon toll.

Ah, dazu fällt mir ein, genau, Space-Data ist natürlich auch noch ein Problem.

Da gibt es irgendwie einen Sparse-Type von Sci-Pi, das hat man früher mal verwendet.

Es gibt ein paar Modelle, die halt in Cycle Learn mit sparsen-Daten umgehen können.

Also das sind halt, also Sparse heißt Daten, bei denen die meisten Werte null sind.

Also zum Beispiel, wenn ich jetzt einen Text oder eine Menge von Texten in Vektoren verwandle, dann ist jedes Wort eine Dimensionen sozusagen.

Und das heißt, ich habe eine Tabelle mit, wenn ich einen kompletten Text, wenn ich eine Menge von Texten in eine Matrix verwandeln möchte, in so eine Feature-Matrix verwandeln möchte, und dann ist jedes Dokument 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, dass halt dich zu speichern, diese ganzen Nullen immer mit zu speichern, weil eigentlich interessieren die einen ja gar nicht.

Und dafür gibt es dann so Space-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 in der letzten Release von Panas war auch ein natives Space-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 Scikit 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 SikedLearn, Stats Models?

Sci-Py, ja.

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 hatte irgendwie so eine dicke Kiste mit irgendwie, weiß ich nicht, 64 Prozessoren, irgendwie einem halben Terabyte Hauptspeicher oder so wie sowas.

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 DASK.

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.

So ist es halt 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, oder ich glaube, 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 Data Frame und die Geschwindigkeit hat sich dann, wenn man, wenn man Glück gehabt hat, halt irgendwie linear ist dann 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 nochmal angucken sollte.

Also was zu Skalierungsgeschichten angeht.

Ja, wenn die Datenmengen dann noch viel größer sind oder dass sie halt nicht mehr in den Hauptsprecher auf einer Maschine passen oder so, dann muss man sich nochmal was anderes überlegen.

Dann bleibt eigentlich nur, dass man das dann, dass man irgendwie dann Richtung Spark geht oder sowas.

Aber diesen Fall hat man fast nie, weil mittlerweile die Maschinen so viele Hauptspeicher haben, dass das irgendwie kaum vorkommt.

Wenn es nicht mehr einen Hauptsprecher passt, Geld dagegen werfen und mehr Hauptspeicher entworfen.

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 Where's McKinney, hast du kurz erwähnt, da hatten wir, glaube ich, einmal in unserer Weihnachtsfolge, die Stand 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 halt 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 irgendwie was machen möchte, dann muss man die halt irgendwie erst, wenn die jetzt in Python hat, serialisieren, irgendwo hin auf die Platte schreiben, dann in

A wieder einlesen und hat sie dann im Endeffekt zweimal im Hauptspeicher, was natürlich irgendwie doof ist.

Und das Projekt ist sozusagen eine 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 was weiß ich, von Java bis C, C<unk>, 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, irgendwie momentan so ein, 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 Dumpai auch nehmen kann.

Also eine Geschichte ist, wo das, dass man in Pandas das nicht so wirklich schmerzfrei Numpai austauschen kann, weil das halt viele Sachen in Pandas buhen halt darauf, dass Numpai so ist, wie es ist.

Das wird halt schwierig.

Da gibt es auch eine Serie von Artikeln zu, nennt sich Pandas 2.0 irgendwie, wo man dann halt überlegt, dass man die API so nicht abwärtskompatibel ändert.

Dazu hat WesmerKinney 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 irgendwie viel auch an dem Frontend von Pandas ändern und das wird da halt nochmal schwierig.

Und es ist so, dass was auch noch in nächster Zeit bei Arrow ansteht, ist, es gibt so einen großen, so eine große 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 daran wird halt gerade geschrieben.

Also nächsten, ich glaube, das ist das Projekt so für die nächsten zwei, drei Jahre in Arrow ist halt so, wäre doch schickt, da auch so eine SQL-Engine drauf zu haben, sodass man halt Arrow 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 so Datenbanken hat, auch noch nicht.

Also ganzen Indic-Index-Geschichten und so.

Und ja.

Da läuft das aber irgendwie so hin.

Also ich meine, wenn man jetzt sich so eine ideale Zukunft mal ausmalen würde, könnte, würde ich sagen, wäre das eigentlich sowas.

Man hat eben so ein In-Memory Storage, äh, als 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 Ves McKinney, 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, die man da macht und dann am Schluss sagt man so und jetzt ausführen und dann geht das quasi an so ein 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 oder das alles ziemlich hässlich.

Und man kann auch nicht so wirklich Code-Sheren.

Also wenn jetzt, es gibt nicht sowas wie Funktionen, 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 schöner.

Ja, und das dann halt auch nochmal ändern.

Weil mit SQL-Statement konntest du das ja auch 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 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 Arrow-Extension-API.

Aber für große Datenmengen, dass man halt so was ähnliches hat wie eben Spark oder auch Loop, 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 Pannas-ähnlichen Frontend aus, wo man dann halt definiert, was man gerne hätte und das dann halt irgendwie auf den Cluster verteilt wird.

Dass man halt 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.

So dass man dann halt auch auf wirklich großen Datenmengen einfach so Transformationen machen kann wie in Pandas.

Das wird vielleicht noch ein paar Jahre dauern, aber das wäre so das, was ich mir wünschen würde, was passiert.

Und dass man vielleicht irgendwann dann tatsächlich Pandas 2.0 hat, wo man nochmal komplett neu irgendwie diese ganzen Geschichten, die bei in der Kombination mit Numpi halt nicht so toll sind, gelöst werden, aber das kann auch sein, dass das nie passiert, weil so viele Leute jetzt Panas verwenden.

Ja.

Ich sagte gerade noch, also, 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, ich.

Das Projekt ist ja schon, da gibt es ja gut Leute.

Also ich kann es auch kaum erwarten, aber es wird wahrscheinlich noch ein paar Jährchen dauern.

So schnell ist das nicht umzusetzen.

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, Reads V, sollte man sich auch mal angucken.

Ja, okay.

Also Datenimport.

Aber sonst, ja, ne, klar.

Doch.

Ja, schön, schön.

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.

Simon, möchtest du anfangen?

Irgendwie hast du ein Lieblingspick, irgendein Modul, was du.

Da muss ich kurz einen Moment drüber nachdenken.

Bitte, dann esse Jochen zuerst.

Ja, ich überlege gerade, ob ich irgendwas Pandasmäßiges habe, aber ich fürchte, nee, ich mal, was man sich mal angucken kann, ist eine Bibliothek namens Alkali.

Das ist so ein Django ORM-Style-Ding.

Aber für flache Files.

Und das ist halt auch ganz, ganz nett, wenn man jetzt irgendwie zum Beispiel irgendwelche, wenn man halt Django kann, zum Beispiel, und den ORM 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 Panas zu machen.

Aber wenn man das nicht kann, dann kann man halt auch irgendwie, wenn man Daten als CSV rausgeschrieben 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 ja schon mal oder so, ich fand das total super, dass man da so Python-Objekte 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 Data Frames machen, oder?

Ich weiß jetzt nicht, wie schnell sowas geht und ob man das nicht lieber in der Datenbank dann speichert, aber.

Doch, kann man mit Data Frames auch machen.

Ist auch tatsächlich ziemlich schnell.

Ist auch, habe ich oft gemacht.

Wenn man Lust macht und wieder anfangen muss, immer an der gleichen Stelle zu debuggen, dann lädt man einfach dann irgendwann den Pickel ein oder so.

Spart nicht immer die Zeit vor dem Ausführen.

Ja.

Also genau, 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 einen Pickelfile gibt, ist er so, hier, so ein, wie wäre das bei der Silha Straße immer so, macht so einen French Code auch so?

Psst will so ein Pickel-Pfeil von mir deserialisieren.

Genau, dann lieber nicht machen, weil das führt halt beliebigen Code aus und ja, das ist vielleicht nicht so schön.

Aber wenn man das selber generiert hat, dann ist es ja vielleicht okay.

Und dann ist es auch sehr schnell.

Also da kann man durchaus, also wenn die IO, ich habe das nicht an die Grenzen, oder warte, nee, 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, also ging halt so Gigabyte pro Sekunde halt durch.

Sobald bei CSV ist richtig langsam.

CSV ist halt so ein, wenn es schnell ist, ein paar 10 Megabyte pro Sekunde.

Was halt, wenn du ein paar Gigabyte große Files hast, dann dauert das.

Und Pickel ist halt so, selbst wenn die Files Gigabytes groß sind, kann es sein, dass halt, wenn das IO-System, 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 HDF zum Beispiel oder Pheather gibt es da auch eine Library, wo wir 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.

HDF5 geht so, ist ein bisschen, ist nicht ganz so schnell, aber ja, lass mal überlegen, gibt es sonst noch irgendwelche Formate, die interessant sind?

Es gibt dieses NetCDF4, das ist die Weiterentwicklung von HDF.

Und da hat man dann.

Hier ist die Weiterentwicklung von 5.

NetCDF4.

Das ist schon die vierte Iteration von NetCDF, aber irgendwann sind die wohl aus HDF entstanden.

Wie das genau zustande ist 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.

Ja.

Sim, hast du noch ein Lieblingsmodul?

Ja, ich habe ja eben schon gesagt, ich mag Plotly unheimlich gerne.

Aber wenn man Plotly-Graphen 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-Graphen, wo man, das funktioniert noch nicht perfekt, aber so die Basisgraphen wie Boxplots oder Scatterplots oder sowas kriegt man damit in Matplotlib ganz schnell definiert, irgendwie mit zwei, drei Zeilen Code und dann mit einer Zeile konvertiert in Plotly-Graphen.

Und dann hat man direkt dieses interaktive, man hat Maushover und man kann zoomen und so.

Das fand ich ganz schön.

Ist aber noch in den Kinderschuhen.

Ist neu in den Kinderschuhen, ja.

Ja, aber finde ich das spannend zu verfolgen, ja.

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 glaubt es wahrscheinlich nicht.

So eine Podcast-Konferenz in Köln.

Ja, die Subscribe.

Bei uns genau um die Ecke ist, dachten wir gehen da auch mal hin.

Genau, und die uns finden.

Genau, da könnte man uns treffen, wenn man wollte.

Also wer möchte, kann einfach eine Mail an uns.

Das kommt in den Veranstaltungen bei.

Genau, aber ihr könnt uns da gerne treffen tatsächlich.

Ich wusste noch nicht genau, ob wir Freitag und Samstag und Sonntag da sind.

Aber auf jeden Fall am Samstag und am Sonntag werdet ihr es wahrscheinlich da sehen.

Das besprechen wir noch genauer.

Ja, es kommt so.

Ist ja immer mal wieder Django zur Sprache gekommen.

Anfang April ist die Django Con in Kopenhagen.

Oh ja.

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, einen Tag Django Lernen.

Ja, ja.

Da fliege ich kurz hin als Mentor.

Ich habe leider für die Konferenz selber keine Zeit.

Ja, 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, äh, irgendwie, aber ihr solltet dann mal vielleicht irgendwie ein paar Sachen an eurem Feed erinnern, da muss ich jetzt nochmal ran.

Zum Beispiel sowas wie Episodennummern sollten nicht im Titel sein und so.

Das machen aber alle, ich auch.

Weil doch nochmal irgendwas dran tun.

Und genau, ich, ja, wir machen da auch so einen kleinen Workshop irgendwie auf dem auf der Subscribe und was auch noch ein bisschen was für tun.

Und da wäre es natürlich auch interessant, was da noch so, also was ich jetzt schon implementiert habe, ist, dass man jetzt nicht mehr das dann ein Jugendmin-Interface braucht, um irgendwie Audio-Files hochzuladen.

Aber ja, mal gucken, was da noch so dazu kommt und dann, was super dringend ist, ist irgendwie, dass die Dokumentation mal so ein bisschen besser wird und so.

Mal gucken, ob ich das Weizen zu schreiben.

Ja.

Zumindest so den First Step oder so.

Den großen Struggle.

Ja, wenn ihr irgendwie so Anfänger seid wie ich, dann kommt ihr da bestimmt noch irgendwo dran.

Ja.

Ja, dann vielen Dank, dass ihr zugehört habt heute auch 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.python podcast.de.

Und ja, gebt uns weiter an alle Leute, die Python interessiert in eurer Nähe, erzeitt euren Freunden, Kommilitonen.

Ja, das kann man vielleicht auch mal, was man auch machen kann, ist auf iTunes bewerten, wenn das irgendwie, also das hilft natürlich stark.

Aber genau, ansonsten, ja.

Ja, genau.

Sag's 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.

Danke für die Einladung.

Tschüss.

Tschüss.