Transcript: PP06 - Pandas

Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Paisen-Podcast in der mittlerweile sechsten Episode.

Heute geht es um Pandas. Ja, was machen wir eigentlich? Wir sind, wie fast immer, in Jochens Wintergarten.

Ich bin der Dominik, dabei ist wie immer der Jochen und mein Gast, der Simon.

Ja, hallo Simon.

Hi.

Genau, vielleicht kannst du dich einfach mal kurz vorstellen, bevor wir über das Thema reden.

Klar. Ja, ich bin Simon. Ich bin von Haus aus Biologe, immer mit Interesse für Informatik und Spieleentwicklung gesegnet gewesen und habe das dann irgendwie auch zu meinem Beruf gemacht.

Also ich habe nach meinem Bio-Studium ein bisschen geforscht in der Bio-Informatik. Da ging es dann viel um Datenanalyse von DNA-Sequenzen und so Dingen.

Game of Life.

Game of Life, ja, quasi. Nur in echt echt.

Und zusammen mit dem Wissen, was ich daraus getragen habe und meinem Interesse an Informatik und Spieleentwicklung,

mache ich heute als selbstständiger IT-Trainer Trainings für Game Engines und Trainings für Softwareentwicklung und parallel noch ein paar Softwareprojekte.

Um das Gaming haben wir uns ja schon ein bisschen unterhalten, das machen wir auch nach der Folge ein bisschen intensiver.

Aber heute soll es ja um Pandas gehen.

Genau, heute...

Deswegen, ja, super, dass du das auch ganz viel mit deinem zu tun hattest in deinem Fach, in deiner Wissenschaft.

Bevor wir aber jetzt auf das Pandas-Thema eingehen,

würde ich gerne noch so ein bisschen wieder

Formalkrams abarbeiten.

Wenn ihr Fragen, Anmerkungen

habt, Lobkommentare, Hass,

dann schreibt uns doch an

hallo-podcast.de

Ihr findet natürlich die links und alle zusätzlichen Informationen

wie in den Shownotes.

Es gab noch ein bisschen User-Feedback und zwar

sollten wir irgendwann mal eine Folge machen

über Do's und Don'ts im Programmieren.

Also seid doch bitte so nett

und schickt uns einfach per E-Mail eure

Do's und eure Don'ts. Das wäre super,

dann schneiden wir das ein bisschen zusammen und fragen

euch in einer der nächsten Folgen bestimmt irgendwann mal danach.

Ja.

Doch, es gab noch ein anderes eben zu der Datenbank-

Folge, dass sie, dass das gar nicht so

schlimm gewesen wäre mit der Länge und das

ja, fand ich

auch ganz gut. Ist übrigens vielleicht ganz interessant, also wenn man sich

anguckt, welche Folgen komplett

runtergeladen wurden, dann hat die beste Quote tatsächlich

die Datenbank-Folge zur Zeit.

Was ich ein bisschen überraschend finde. Ich hätte jetzt auch erwartet,

dass es eher ein bisschen runter geht, aber ja.

Vielleicht müssen wir noch mehr so Buzzword-Bingo-Sachen machen

und dann ganz viele tolle Klickzahlen bekommen.

Nein, wir machen das natürlich für alle unsere Hörer, vor allen Dingen für die, die sich dafür wirklich interessieren und natürlich auch für die Leute, die was lernen wollen und für alle Leute, die einfach so reinhören oder denen langweilig ist oder ihr wisst ja, morgens, abends, nachts, beim Aufstehen im Flugzeug könnt ihr immer hören.

Ja, bevor wir in das Thema gehen, ist weiterhin noch ein paar News aus der Szene und zwar gab es so ein bisschen was Neues, glaube ich.

Python 3.8, zweite Alpha.

Ja.

Ja, da gab es so ein paar coole neue Sachen mit Shared Memory for Multiprocessing.

Jochen, was ist das denn?

Ja, das ist eine gute Frage.

wann habe ich denn das da reingeschrieben?

Oh, ja, das ist auch schon ein bisschen her, kann ich gar nicht.

Ah doch, ja, alles klar.

Das ist ja immer so.

Das war ja immer so ein Problem.

Also man muss ja, wenn man jetzt über mehrere Prozessoren

Berechnungen verteilen will in Python,

das auf mehreren Prozessen machen,

weil man ja irgendwie so ein Global Interpreter-Log hat,

das halt verhindert, dass man das innerhalb von einem Prozess

irgendwie mehrere Prozessoren benutzen kann.

Und ja, früher hat man halt immer so das, oder hat man jetzt immer noch in der stabilen Version, aber vielleicht hat man das mit 3.8. nicht mehr so, das Problem, dass man, wenn man jetzt eine Funktion aufrufen möchte und, sagen wir mal so, man startet halt einen Pool von 5 Prozessen oder sowas oder 10 und eben so viele üblicherweise, wie man Prozessoren hat und ruft jetzt eine Funktion auf jedem Prozessor sozusagen auf.

Also man hat jetzt eine Liste von Dingen, die man irgendwie abarbeiten möchte, man hat eine Funktion, die das dann halt tut, dann sagt man, okay, starte mit diesem Job irgendwie diese Funktion und das geht dann halt irgendwie auf jeden Prozess, der halt in diesem Pool ist, wird dann halt das irgendwie gestartet.

Also wie man im Supermarkt ganz viele verschiedene Kassen aufmacht und macht ein paar Kassen auf einmal auf.

Ja, ja, ja. Das Problem ist jetzt, dass man, wenn man da irgendwie auch Daten hat, auf denen da gearbeitet wird, dann muss man die Daten irgendwie zu diesen Prozessen bringen. Das ist jetzt ein anderer Prozess. Das heißt, man kann nicht einfach das, also im Code ist es schon so, dass man einfach einen Funktionsaufruf macht. Aber was dann im Hintergrund passieren muss, ist ja irgendwie, dass die Daten serialisiert werden. Dann müssen sie irgendwie durch die Gegend geschoben werden und dann auf der anderen Seite wieder deserialisiert werden.

In so kleine Häppchen und dass

die ganze große Bestellung an verschiedenen Kassen

abgearbeitet wird, um danach wieder in der richtigen Reihenfolge

im Einkaufskraub zu landen.

So ungefähr?

Ja, man kann...

15 Fehler wieder in einem Kasten.

Ich weiß nicht, ob die Analogie da in der Stunde

so gut passt.

Ich weiß auch nicht genau.

Ja, man

muss es, ja.

Man kann sich vielleicht vorstellen, dass man, wenn man jetzt

einen riesen Einkaufswagen voll Zeug hat

und möchte jetzt das an fünf Kassen

aber bezahlen, dann

muss man halt auch fünf Einkaufswagen haben, in die man

das jetzt aufteilt und mit jedem Einkaufswagen

einzeln zu einer Kasse und

dann muss die

irgendwer umpacken. Dann muss man die umpacken,

genau, und das ist halt alles

halbwegs aufwendig und

kann halt auch zu Problemen führen, wenn die Daten sehr groß

werden zum Beispiel, dann kann es sein, dass irgendwelche

Dinge dazwischen halt aussteigen und das ist alles

nicht so schön und

ist es halt unter Umständen auch etwas, was

Dinge langsam macht und jetzt geht es aber

transparent mit Chat-Memory sozusagen.

Das heißt, man hat halt die Daten, genau, das ist ja auch so ein Problem, wenn man jetzt Daten serialisiert und deserialisieren muss, dann kopiert man sie damit natürlich auch. Das heißt, wenn man große Daten hat, die jetzt vielleicht insgesamt nur einmal in den Hauptspeicher passen, aber nicht zweimal, wenn man sie kopiert, dann hat man sie halt zweimal drin und dann hat man so wenig Hauptspeicher, ist ja auch blöd.

Und was halt schon immer viel, viel cooler war, ist, wenn man halt einfach Shared Memory reservieren kann und sagt dann den einzelnen Prozessen, gibt denen nur einen Pointer auf diese Shared Memory und sagt so, da sind deine Datenstrukturen drin.

Also das heißt, jemand nimmt sich einfach so einen Unterkorb aus dem Einkaufswagen raus, der schon fertig ist und der Einkaufskorb, der fährt dann automatisch auf das richtige Förderband.

Ja, nee, aber das ist, ja, mal überlegen, ob man diese Analogie da noch irgendwie findet.

Ja, Shared Memory, ein eingeteilter Einkaufswagen

fällt mir jetzt auch tatsächlich schwer.

Das wäre der eine Einkaufswagen, der an allen fünf Kassen steht.

Jede Kasse greift nur auf

einen Teil von dem Korb selber zu.

Stimmt, wir haben eine Bohre von Kassen.

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

eingreifen. Das ist schön, ja.

Genau, so könnte man sich das vorstellen, ja.

Und das heißt, man hat halt

selbst wenn man jetzt Daten hat, die

so gerade in den Hauptspeicher vielleicht passen,

dann kann man die trotzdem auf mehreren Prozessen verarbeiten.

Und das macht natürlich

Multiprocessing auf Python deutlich attraktiver und

das ist irgendwie eine ziemlich coole Geschichte, wenn ihr jetzt in 3.8

kommt. Da wird Python ja schneller.

Ja, also, oder es wird einfacher

damit, also man kann ja auch, das konnte man auch sowieso

schon immer machen, man kann ja auch einfach

Standard-Memory reservieren, da Dinge

reinpacken, da gibt es übrigens auch

ein schönes

Modul in der

Standard-Bibliothek, das heißt Struct.

Struct? Genau, damit

kann man zum Beispiel Daten

halt so binär

irgendwie in den

Hauptspeicher schreiben.

Und

das zum Beispiel so tun, dass das halt

C-Structs sind.

Und dann kann man

das halt, also das ist halt so etwas,

so haben wir das früher halt gemacht, wenn wir Daten

nicht so groß waren, dass man da nicht einfach

irgendwas mehr tun konnte.

Das heißt, man hat halt irgendwie

einen Shared-Memory-Bereich, in den schreibt man halt

irgendwie per Struct irgendwie

sozusagen C-Struct-Daten

irgendwie rein und hat dann Python-Prozesse,

die wiederum einen Pointer auf diese Shared-Memory

kriegen und

die dann halt wieder ein C-Modul

haben, das dann halt irgendwas mit den Daten macht und so.

Und dann geht das auch schon, aber es ist halt viel Handarbeit

und jetzt kriegt man das quasi so geschenkt

und das passiert alles automatisch und das ist halt

schon sehr, sehr nett.

Hört ja auch gerade diese Hintergrundmusik, das ist so ein bisschen wie

in Battlestar Galactica, diese

G...

Keine Opelide.

Ja, die nächsten News aus der Szene.

Doppelte Keys, gab es einen Post

von Guido irgendwo, der hat irgendwas geshared.

Es gibt ein neues Python-Enhancement-Proposal,

das eine ganz interessante Geschichte vorschlägt.

Und zwar geht es darum, dass man halt für Dicts

vielleicht auch die Plus und Minus als Operatoren haben möchte,

sodass man halt sagen kann, irgendwie Dict A plus Dict B.

Und dann werden sozusagen die Keys hinzugefügt

oder halt wird das eine,

werden halt die Keys, die in dem einen Ding drin sind, entfernt,

wenn man das halt abzieht.

Und das ist natürlich auch eine ganz,

Also es ist eigentlich relativ naheliegend.

Es wundert mich, dass da bisher noch niemand drauf gekommen ist,

dass man das irgendwie mal machen könnte.

Aber das ist auf jeden Fall eine ganz interessante Idee.

Und Guido hat da einen Artikel zugeschrieben.

Ja genau, der hat zweimal den Key irgendwie draus zugewiesen

und dann quasi einen Dictionary mit zwei identischen Keys erzeugt,

wo dann nur einer von überlebt hat.

Ja.

Irgendwie so.

Also wenn man halt, ich glaube, welcher Post war das?

Wo er A einmal die Nullen, A einmal die Eins zugewiesen hat

und dann war eins

übrig, weil das die letzte Zuweisung war.

Weil ich das richtig verstanden habe.

Genau, das war das Verhalten, was mich irgendwie

gewundert hat, aber das ist generell

so, das war schon immer so, offenbar,

wenn man halt, also insofern

ist es halt kompatibel mit diesem Verhalten,

dass wenn man

jetzt irgendwie ein Key mehrfach in einem Dikt hat,

dass dann halt immer das letzte genommen wird.

Und das war mir auch gar nicht klar,

dass das so ist, aber...

Also kein Duplicate Value oder Key Error oder sowas?

nein, nein, es wird einfach das Letzte genommen.

Und da hat er halt dazu, oder auf der Mail-Industrie geschrieben,

dass, ja, er hat damals lange drüber nachgedacht,

weil irgendjemand die Frage gestellt hat,

ob das Absicht wäre oder nicht.

Er meinte so, ich habe damals lange drüber nachgedacht

und es ist Absicht.

Ich erinnere mich an ein Programm, wo ich das dachte,

wo ich irgendwie einen komischen Fehler hatte,

und das, glaube ich, genau daran gelegen hat.

Weil, ja, irgendwelche Duplikate dann zwar drin waren,

ich das aber nicht gemerkt habe, erst irgendwann später,

als mir um die Ohren flog.

Ja, aber Guido hatte auch noch einen Blogpost dazu geschrieben, wo er überlegt hat, ob das mit diesen Operatoren halt eine gute Idee ist oder nicht.

Siehst du, wie diese Code Active State heißen, Ideas?

Ja, in seinem Blog war das Ding drin.

Und ja, da macht er tatsächlich den Punkt, dass das halt schon eine gute Idee ist.

hat da so das als Beispiel

quasi, wenn man jetzt mathematische, also

arithmetische Geschichten halt nicht

als Operatoren hätte, sondern

wenn man das mit Funktionen ausschreiben würde,

dann wird es halt sehr viel unklarer,

was eigentlich gemeint ist, jedenfalls wenn das

irgendwie komplizierter wird, weil man dann halt immer

erst die Funktion

mit den Klammern auflösen muss,

bevor man sieht, was passiert und während man

quasi, wenn man das als Operatoren

hinschreibt, hat man so eine Art visuelles Pattern-Matching

direkt schon, dass einem sagt, was

da passiert und daher sind für so

arithmetische Geschichten, um zu sehen, was da

passiert, ist es halt viel

sinnvoller, das mit Operatorenschreibweise

hinzuschreiben als mit Funktionen,

was man ja auch tun könnte.

Und für Dicts ist

halt die Frage, ob das Sinn macht, aber

also immer dann, wenn einem das dabei beim

Verständnis hilft, wenn man das anders hinschreiben

kann, dann kann es natürlich schon gut sein,

dass das irgendwie sinnvoll ist.

Und ja, das ist auf jeden Fall

glaube ich hier ein starkes Argument,

dafür und mal sehen.

Ich bin mir nicht sicher, ob wir das in Python 3.8

dann schon direkt sehen werden, aber es wäre auf jeden Fall

irgendwie eine interessante Idee

und ja, ich bin mal gespannt, wie das sich so weiterentwickelt.

Okay, okay.

Ja, noch eine

kleine News hatten wir, glaube ich, und das war der

Django Chat Podcast.

Genau, ja, es kommen ab und zu

neue Podcasts dazu und jetzt

fand ich besonders interessant

eben auch Django, ein Podcast,

der sich nur Django widmet, da

einer der beiden ist irgendwie einer der beiden

Django Fellows, die halt quasi sich, also

dafür auch bezahlt werden, da tatsächlich

an Django zu arbeiten und so die ganzen

Sachen zu machen, die halt normalerweise niemand tut, wenn er

nicht dafür bezahlt wird, halt irgendwie

zum Issue-Tracker kümmern

und

Releases machen und so.

Ja, und

das war schon, die ersten beiden

Episoden sind erschienen, die

erste war irgendwie relativ interessant.

Ich fand, das war auch so, dass da irgendwie eine ganze

Menge Überschneidung war zu dem, was wir in unserer

Django-Folge irgendwie erzählt haben, so von dem

so Rundtenor.

Ich seh grad, ich hab den auch gehört, ich bin begeistert.

Ja. Und eine Folge.

Gefällt mir sehr gut, also es ist

wirklich toll. Jetzt kam noch eine zweite Folge, die war

so eine kurze Folge dazu. Fünf Minuten.

Könnt ihr mal sehen, wie man in der

Kürze die Würze finden kann. Ja.

Weil sie halt irgendwie mal

ein Release von Django kaputt gemacht haben.

Ja. Und

ich bin mal gespannt, wie sich das so weiterentwickelt.

Das ist auf jeden Fall eine sehr empfehlenswerte

Geschichte. Dann gab's noch einen anderen

Pouted Patent Out Loud, aber da müssen wir nochmal gucken, also den fand ich

jetzt gar nicht so interessant

am Anfang. Ja, falls ihr noch einen Podcast

kennt, den wir noch nicht kennen, dann schickt ihn uns,

wir sind neugierig natürlich.

Ja, ich würde sagen, am Ende stellen wir nochmal so ein bisschen die

Pics der Woche, der Woche, des

Monats vor, aber wir sind glaube ich mittlerweile

so weit, dass wir so ein bisschen jetzt was über Pandas

erzählen können. Ja, Pandas, was ist das denn

überhaupt? Also beim Eishockey, ich bin ja

Eishockey-Finder, haben die Schiedsrichter jetzt so ein Pandasymbol

gehabt auf den Trikots, weil die eine

Kooperation mit dem WWF haben und dann

waren sie am Ende ein bisschen enttäuscht, dass der WWF da so eine Spendenaffäre

hatte. Aber ja, es ist manchmal so,

aber Pandas und Spendenaffäre hat wahrscheinlich jetzt bei uns

so viel nicht miteinander zu tun.

Nee, aber der Name bietet

natürlich schon so ein bisschen Verwechslungspotenzial.

Wir hatten da auch genau darüber

gesprochen haben, ob wir nicht irgendwie mal zusammen

eine Podcast-Episode machen wollen.

Hatte Simon auch irgendwie zuerst was anderes verstanden,

glaube ich. Ja, genau. Also es gibt

nicht nur Python Pandas

das Data Frame Framework,

sondern auch Python Pandas

3D, die Game Engine.

Ah. Und weil

ich ja irgendwie beide Themen abdecke,

war das, was ich gerade zuletzt

gemacht hatte, das Erste, was im Kopf wieder

aufgetaucht ist und das war die Game Engine und

dann haben wir, weiß nicht, fünf Minuten aneinander

vorbeigeredet. Wir können doch jetzt gerne noch mal

fünf Minuten über die Game Engine, Pandas 3D reden, wenn du magst.

Ist die in Python? Also

ich glaube, Game-Entwicklung

in Python ist vielleicht

eine Folge, zu der ich nochmal wiederkommen sollte.

Oh ja. Einfach, weil das sehr,

sehr umfangreich ist. Und es geht?

Es gibt es im Wesentlichen irgendwie

Pygame und Pandas als die beiden

großen etablierten, dann gibt es noch

so ein paar kleinere. Und damit kann man wirklich auch

Spiele machen, die auch gehen und die auch aussehen

oder sowas? Oder braucht man dafür noch Qt oder

sowas? Ich sage es mal vorsichtig, ja, damit kann man

Spiele machen, mit Pygame

2D-Spiele, mit Pandas 3D sogar

3D-Spiele. Was man

damit sehr gut machen kann, ist zu lernen,

wie so eine Game Engine wirklich funktioniert.

Ich glaube

aber nicht, dass man Triple-A-Titel

darin machen möchte, weil es dann doch irgendwann

umständlicher ist, als

eine von den großen 3D-Game-Engines,

die so am Markt sind,

die vielleicht auch ein bisschen mehr

klickbar sind, zu verwenden.

Ich muss überlegen, welche das waren. Das war Unreal,

Unity und

CryEngine.

Ja, okay, dann CryEngine ist ja nicht

frei. It 7 oder so 8.

Weiß ich gerade gar nicht.

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

Wir wollten über Pandas sprechen. Genau, also Pandas 3D

ist die Game-Engine, darüber sprechen wir heute dann

nicht. Und Pandas

ist im Wesentlichen

eins der Python-Tools,

an denen man nicht vorbeikommt, wenn man Datenanalyse

betreibt. Okay, wir sind

wieder mal bei der Datenanalyse.

Datenbanken hatten wir übrigens in der letzten Folge,

für alle, die sich das noch nicht angehört haben, eine ziemliche Mammut-Folge

mit, wie lange, drei Stunden haben wir

gebraucht? Ja, ein bisschen mehr, aber

genau um den Dreh. Wenn ihr mal wieder die Wohnung

richtig putzen wollt, dann was soll ich, die Ohren?

Ja,

an der Stelle würde ich ganz gerne noch kurz

meinen Hintergrund in der Datenanalyse

erwähnen, damit man so ein bisschen einordnen kann,

aus welcher Richtung meine Kommentare

kommen. Als

Biologe war damals

Perl die große

Programmiersprache, um alles zu lösen.

Und erst zum Ende

meiner Forschungszeit hat sich dann irgendwann

Python durchgesetzt. Das heißt, ich habe noch sehr

viel in Perl gemacht. Und

was man in Perl gar nicht gut

konnte, zumindest ich konnte das nicht, ist

Daten nachher analysieren

und visualisieren. Aber die

Aufbereitung war da sehr gut. Das heißt,

für die Analyse und die

Visualisierung sind wir dann immer zu R

rüber gewechselt. R ist

auch eine Programmiersprache,

ist eine eher mathematische

Annotation zur

Datenanalyse.

Und wenn ich so

die Branche, sage ich mal, richtig

überblicke, dann wird am meisten

R und Python

benutzt und vielleicht dann noch

MATLAB als

dritte Alternative,

wenn Leute heute Datenanalyse machen.

Was meinst du denn

mit Datenbereinigung?

In der Biologie ist das so,

dass die Daten immer unheimlich fuzzy sind.

Also man hat nie ganz konkrete Messwerte,

sondern man hat immer super viele Abweichungen,

mal Fehlmessungen, mal Werte, die man gar nicht erheben konnte.

Du musst dich dann entscheiden,

ob du eine Rundung anwendest oder nicht.

Vieles davon führt dann erst mal dazu,

dass die Daten nicht mehr so strukturiert sind,

wie man das eigentlich dachte in der Tabelle.

Das kommt auf die Messinstrumente im Wesentlichen an.

Das heißt, die erste Aufbereitung ist erstmal,

die Daten in ein maschinenlesbares Format zu bringen.

Und da ist es von unfassbarem Wert, wenn man programmieren kann.

Dann muss man jede einzelne Zeile oder Zelle durchgehen

und die manuell korrigieren.

Genau, also ich habe auch tatsächlich schon Kollegen damals gesehen,

die von Programmierung gar keine Ahnung hatten,

die dann angefangen haben, in Excel sich das händisch zusammenzustellen

Und dann haben wir uns kurz zusammengesetzt, ein Makro geschrieben und dann ging das irgendwie doch schneller. Und fehlerfreier an der Stelle auch. Und dieser erste Schritt, überhaupt die Daten erstmal maschinenlesbar zu kriegen, der ist im Wesentlichen unabhängig von der Analyse, aber notwendig.

Und nochmal für unsere ganz Anfängerhörer, was denn überhaupt maschinenlesbar bedeutet?

Ich habe da mal irgendwann ein Beispiel vorbereitet für Mediziner, die von Excel zu R wechseln wollten.

Und das Beispiel war eine Tabelle, eine Excel-Tabelle aus meinem Laboralltag,

wo dann in einem Tabellenblatt an mehreren verschiedenen Stellen so kleine Subtabellen zu sehen waren,

wo die Messdaten drin standen.

Da gab es dann quasi einmal Experiment A war so ein 5x4-Raster,

Experiment B war so ein 5x4-Raster, was irgendwie rechts daneben stand.

Und dann gab es noch ein Experiment C, was dann mittig darunter stand,

auch 5x4-Raster.

Das ist für den Menschen super lesbar,

weil man kann sofort die Blöcke identifizieren

und sich die Messdaten angucken.

Für eine Maschine ist das aber nicht mehr strukturiert lesbar,

weil die Koordinaten nicht klar sind.

Und was häufig passiert ist, wenn Menschen Tabellen ausfüllen, um die visuell ansprechend zu machen, verletzen die ein wichtiges Kriterium, dass in jeder Zeile oder Spalte, je nachdem, woran man sich orientieren möchte, nur ein Datensatz wirklich drinsteht.

Oder stehen sollte, weil da unterschiedliche Informationen sind, die nicht voneinander getrennt sind. Dann stehen zum Beispiel sowas wie eine Spalte, wo zwei verschiedene Datensachen auf einmal drin stehen. Einmal Temperatur in Celsius, einmal in Fahrenheit oder sowas. Oder ist das legitim?

Das könnte ja noch zusammenpassen, aber einmal die Temperaturen in Celsius und Fahrenheit für das eine Experiment und dann das Ganze nochmal für das andere Experiment irgendwo weiter hinten in der gleichen Zeile, aber nicht klar strukturiert abgrenzbar.

Ja, also das ist halt quasi bei Datenmarken die erste Normalform, dass man in der Spalte immer nur einen Wert stehen hat und nicht mehrere zum Beispiel, was halt dann manche Leute tun.

Also Fahnenheit und Zeltes wäre okay, wenn man die Information enthalten wäre in der Zelle, ob es Zeltes oder Fahnenheit wäre.

Weil das wäre sonst problematisch.

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

Grundsätzlich, wenn man so eine Tabelle hat, wo man Zeilenbeschriftungen hat und Spaltenbeschriftungen hat und die ganze Tabelle ist rechteckig,

dann kriegt man die auch sinnvoll maschinenlesbar ausgewertet.

Also Probleme fangen dann an, wenn man keine zweidimensionalen Tabellen mehr hat,

keine, die man mal eben so auf seinen Whiteboard malen kann,

welche, die man bauen müsste oder wo man irgendwelche Dimensionen verbraucht,

die wir uns jetzt nicht so räumlich vorstellen können.

Oder wo tatsächlich Lücken drin sind und die Muster für Menschen zwar noch erkennbar bleiben,

aber für eine Maschine die Koordinaten dann zum Beispiel nicht mehr zusammenpassen.

Okay.

Okay.

Ja, okay, das haben wir so ungefähr verstanden, was so maschinenlesbar dann bedeutet für die einzelnen Daten. Und wo kommt jetzt Pandas dann ins Spiel?

Ich habe mal, ich glaube, das war Python User Group Treffen oder irgendwie sowas in der Richtung, habe ich mal eine Folie gesehen in einem Vortrag. Ich habe die leider nie wiedergefunden. Da fand ich das ganz schön beschrieben. Da waren irgendwie so Python-Module konzentrisch angeordnet und im innersten Kreis war NumPy oder NumPy, SciPy und Matplotlib für die Darstellung von Vektoren.

NumPy und für

einfache statistische Analysen

SciPy und für Visualisierung

Matplotlib. Und dann war

der Kreis eins weiter draußen

so ein bisschen das, was darauf aufbaut.

Das war dann Pandas,

das war

Statsmodels, war das

glaube ich. Also für Zeitreihen

und so. Genau. Und

Seaborn. Und das waren dann die

Pendants. Also Seaborn auch

wieder zur Visualisierung und Statsmodels

im Prinzip zur statistischen

Auswertung und Pandas eben zum

Data Handling, aber

jenseits von einfachen Vektoren.

Aha, okay.

So, und da kommen wir im Prinzip auch schon wieder in den Bereich,

wo man immer den Vergleich zwischen Excel normalerweise

führt, wenn man das mit Leuten

bespricht, mit denen man zusammenarbeitet,

weil Excel kennt irgendwie jeder. Also

Tabellenkalkulation ist jedem sofort

ein Begriff und alle wissen auch sofort,

okay, es gibt Zeilen und Spalten.

Das ist so, dass das

bare minimum, was man wissen muss, um

mit Pandas was anfangen zu können.

Das hat man wahrscheinlich in der Schule schon mal aufgemacht oder so,

oder aufmachen müssen. In der Regel schon, ja.

Genau, das heißt, bei Pandas

sind wir jetzt in dem Bereich von

Data Handling.

Also, wie kann ich meine Daten

laden, verarbeiten,

zur Verfügung stellen für

Analysen. Und wie

macht Pandas das?

Gibt es da Spezies?

Also ich würde sagen, also das ist auch das

denke ich

Hauptfeature von Pandas ist, dass

man damit die Daten überhaupt erstmal irgendwie

in so ein

ja,

reinbekommt irgendwie. Also

Westman Kinney hat das auch mal gesagt, dass die

populärste und wichtigste Methode, die

Pandas halt hat, ist halt Read CSV,

die sehr, sehr

flexibel ist und man kann irgendwie so ungefähr

jedes CSV, was irgendwo, ein CSV ist

ein sehr hässliches Format und

Leute machen unglaubliche und unheilige

Dinge damit, aber

man kann irgendwie mit dieser

Funktion kann man das fast alles parsen.

Die hat sehr viele

Argumente und sehr viele Dinge, an denen man da irgendwie

was drehen kann und man kriegt fast alles damit geparsed

und

das heißt, egal wie komisch die Daten aussehen,

die man so hat, man kriegt sie irgendwie

mit Readsys wie oft irgendwie

in Pandas rein und hat sie dann halt in einem

sauberen Format und kann das dann halt wieder in anderen Formaten

rausschreiben. Aber gut, Pandas kann nicht nur

CSV lesen, sondern halt auch diverse andere

Formate

von JSON

über, keine Ahnung, XML oder was auch immer.

Teilweise werden dann halt andere

Bibliotheken unten drunter verwendet, um das halt einzulesen.

Aber

das ist halt,

also Pandas ist eigentlich immer so der erste

Schritt, wenn man irgendwo Daten herbekommt,

um die halt in

ein Format zu bringen, mit dem man irgendwas machen kann, um es halt

irgendwie einzulesen in Programmen,

da nimmt man halt eigentlich immer Pandas, weil das halt

Pandas hat so vorbereitete Funktionen für, weiß nicht,

eine Zeitreihenanalyse oder sowas.

Nein, nein, der Analyseteil ist nochmal ein bisschen,

also ja, Pandas kommt auch daher,

also das ist mal

entwickelt worden, Westman Kenny hat das

gestartet, das Projekt 2008, als er bei

RQ Capital, glaube ich, irgendwie so ein

Hedgefonds-Investment-Dings

da gearbeitet hat und

da ging es um

Zeitreihen und

tatsächlich ist bei Pandas immer noch so

der Hauptfokus, oder es ist halt das, was

Pandas auch besonders gut kann, sind halt so Zeitreihen-Geschichten.

Aber man kann auch diverse andere Dinge damit machen.

ja,

da gab es halt noch nichts

in Python. Die Leute haben

damals Excel verwendet oder halt

irgendwie kommerzielle Software

und ja,

da wurde halt

dann ist halt dieses Projekt gestartet.

Und so ein bisschen, auch heute ist es halt noch so, dass viel Geld geht halt so in Deep-Learning-Geschichten, also wenn man sich anguckt, wie viel Geld wird halt eigentlich ausgegeben für Open-Source-Entwicklungen, ist sowieso irgendwie relativ erschreckend, wie wenig Ressourcen sozusagen Open-Source-Projekte haben und wie viele Leute dann und wie viele Firmen im Grunde darauf angewiesen sind, weil wenn man dann anguckt, was Firmen machen, auch große Firmen, dann ist das ja doch im Endeffekt machen die halt ganz viel mit so freier Infrastruktur, Software, die halt irgendwie auch alle Leute kennen und so.

Aber die wird wenig, bekommt eigentlich wenig Ressourcen, da gibt es wenig Geld, da gibt es wenig Leute, die überhaupt beruflich daran arbeiten.

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

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

bekommen und auch in denen steckt

relativ viel Geld drin, aber

diese Sachen sind alle

ziemlich schlecht irgendwie

und Pandas füllte halt so eine Lücke.

Ist halt eigentlich ultra wichtig, weil

irgendwie diese ganzen Datenimport-Export-

Geschichten sind halt etwas, was man immer braucht

und irgendwie es gibt

außer Pandas gibt es keine

Projekte, die das irgendwie ordentlich gemacht haben

und du kannst natürlich irgendwie deine

tolle Deep Learning TensorFlow-Geschichte nehmen

irgendwie, aber wenn du die Daten halt nicht

hast, um damit irgendwas machen zu können,

dann hilft dir das alles nichts

und ja, das

ja, eben Westman Kenny erzählt

davon halt auch immer, dass ihn das total wundert

und dass er das total seltsam findet, dass halt so ein wichtiger

Teil der Infrastruktur so wenig

Liebe erfährt quasi

und

dass seine Hauptmotivation war

zu sagen, okay, da muss man mal was tun

das muss doch irgendwie, dieses Problem muss man

doch lösen, das ist halt irgendwie ein Problem, was alle haben

und was irgendwie sehr ärgerlich ist und

ja

Ja, und das ist halt, das macht Pandas auch sehr gut irgendwie. Und das ist immer so ein erster Schritt, wenn man irgendwie Daten, auch wenn man jetzt hinterher Machine Learning machen möchte oder so, hat man trotzdem immer Pandas mit dabei, weil man die Daten ja erstmal irgendwie in ein Format bringen muss vorher und vielleicht aufräumen muss, sauber machen muss.

Da gibt es auch immer so einen schönen Spruch, irgendwie Data Science ist halt so, oder auch Machine Learning ist halt, 80% ist halt Data Cleaning und 20% ist sich darüber beschweren, dass irgendwie 80% Data Cleaning sind.

Ja, das trifft es sehr gut. Ja, ich meine, die andere Sache ist, als Mensch möchte man ja auch sich die Daten vielleicht zwischendurch mal angucken können. Und dafür braucht man irgendwie eine Datenstruktur, in der man sehr schnell zu Rahmendaten kommt.

Vielleicht braucht man mal einen Mittelwert oder will sich mal die Verteilung angucken, gruppiert bei irgendwelchen Kategorien oder sowas. Also sicherlich ist diese Import-Geschichte von Pandas eine der mächtigsten, die ich bisher gesehen habe, was auch so fehlende Datenpunkte angeht und wenn die Struktur mal nicht ganz stimmt und man kann einzelne Zeilen überspringen, wenn da mal was kaputt geht oder sowas.

Da habe ich jetzt übrigens direkt eine doofe Frage zu, weil es gibt ja irgendwie bei Pandas so ein paar Werte, die, wenn die halt nicht da sind, die man irgendwie füllen kann. Da gibt es ja irgendwie jetzt aber so drei Typen. So Null und None und None. Warum, wieso braucht man da drei?

In Pandas? Also ich wüsste jetzt

eigentlich nur, dass es da Not-a-Number gibt.

Ja. Und das ist

historisch sozusagen der

hier ist kein Wert

von NumPy.

Das ist auch irgendwie sozusagen ganz

unten drunter ist das

tatsächlich ein

in Float kann man das halt ausdrücken und

ja, das hat halt auch so die

leichten, das leichte Problem, dass

man im Grunde immer dann, wenn man solche Werte hat, dann

halt auch der Datentyp irgendwie

Float sein muss, was so ein bisschen doof ist.

Bis vor ganz kurzem war das noch so,

dass man halt, wenn man jetzt eine Integer-Spalte hatte

und da fehlt halt jetzt ein Wert,

und man hat halt gesagt, okay,

da kommt irgendwie was dazu, was halt irgendwie fehlt oder so,

und man macht einen Re-Index und guckt,

und dann hat sich plötzlich der Typ der Spalte in Float geändert,

weil es halt keine fehlenden Werte in Integer-Typ-Typ-Spalten gibt.

Und das ist ein ziemlich blödes Problem.

Aber jetzt gibt es halt irgendwie seit einiger Zeit diese Array Extensions, Array Extensions API für Pandas und die halt mit Cyber Pandas dazugekommen ist.

Ich weiß gar nicht, welche Version das genau war. Und jetzt hat auch Ende Januar ist die letzte größere Release von Pandas erschienen. Ich glaube 0.244 oder so.

0.244, ja.

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

Und das ist natürlich total cool irgendwie.

Und dadurch, dass man jetzt quasi nicht mehr NumPy unten drunter liegen hat, kann man da auch diverse andere coole Datentypen irgendwie verwenden, die vorher so nicht möglich waren, weil man ja immer auf NumPy angewiesen war.

Also NumPy ist auch ganz cool, aber NumPy hat halt das Problem, dass das grundlegende Design dafür ist halt jetzt doch schon wahrscheinlich fast 20 Jahre alt und passt halt auch nicht mehr so richtig auf die Anforderungen von heute und dummerweise hat Panas aber viele der Implementationsdetails in NumPy halt rausgelegt und das kann man jetzt auch nicht mehr so einfach ändern, weil das halt schon, also wenn man das wieder ändern würde, würde das Code brechen und dann wäre keine abwärtskompatiblen Änderungen mehr.

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

Aber

irgendwie mit dieser Array-Extension-API hat man

auf jeden Fall eine Möglichkeit, wenn man den Typ ändert, dann

ist das alles eigentlich in Ordnung.

Und dann kann man da auch schöne neue Sachen machen,

ohne dass man auf NumPy irgendwie angewiesen ist.

Zum Beispiel was halt,

also es sind so Beschränkungen, die sind echt blöd.

Also wenn man auf NumPy

unten drunter basierendes

Pandas hat, dann hat man halt

sowas nicht wie zum Beispiel

Decimal-Types.

Also einmal man hat keine fehlenden, keine

Missing-Value-Support für sowas wie

Integer, was auch schon schlimm ist, aber man hat halt

auch, wenn man jetzt mit Geld zu tun hat,

was man ja vielleicht auch irgendwie,

dann hat man halt bloß Float,

das will man auch nicht. Also man

würde das dann irgendwie wahrscheinlich eher

Geld in Integer, also in Cent-Integer

oder sowas verwenden.

Viele werden wahrscheinlich irgendwie Float

nehmen, so,

und dann denken, ach, das wird schon irgendwie hinhauen

und dann böse Überraschungen überleben,

weil das funktioniert halt

überhaupt gar nicht. Und man

kriegt diverse richtig böse Probleme, wenn man das

macht. Und in Datenbanken

ist das Problem eigentlich auch schon lange gelöst.

Da gibt es den Decimal-Type

genau für sowas, der dann

halt auch ordentlich

rundet und so. Und

in Python gibt es auch einen nativen

Decimal-Type. Der ist blöderweise

nur total super langsam. Also den kann man eigentlich auch

nicht nehmen.

Und jetzt gibt es halt

sozusagen als Array-Extension

Type halt auch Decimal,

sodass man das halt auch in Pandas Data

Frames halt Geld quasi mit Kommastellen

verwenden kann, ohne dass es da irgendwie,

ohne dass man da mit schlimmen

Konsequenzen rechnen muss.

Und es gibt sowas wie

DateTime mit Timezonen

dran und so, das ging vorher auch nicht.

Und das ist... Achso, sowas wie

Grad mit Celsius-Erfahrenheit vielleicht.

Das ist nochmal ein anderes, genau,

das möchte man auch gerne haben.

Ich weiß nicht, ich glaube, das ist nicht direkt in Pandas drin.

Es gibt Bibliotheken dafür, dass man halt

an Spalten auch noch irgendwie so eine

Maßeinheit dran klebt.

Die Annotationen

und auch Skalierungsfaktoren

kommen auch mit unter aus dem

zugrunde liegenden Datenformat, aus dem man nachher

importiert. Also es gibt irgendwie

wissenschaftliche Datenformate, die speichern sowas

alles mit. HDF5

oder NetCDF oder

wie das inzwischen heißt. Wie sieht das dann aus?

Ist da eine Spalte, ein Tupel drin?

Da gibt es im Prinzip

irgendwie so eine Tabelle von

Metadaten, wo drin steht,

welche Spalten, welche Maßeinheit, welches

Skalierungsfaktoren haben, wann die zuletzt

bearbeitet wurden. Und darunter

stehen dann serialisiert die Daten drin.

Und dadurch hat man

sehr, sehr schnellen, sequentiellen

Zugriff auf seine Daten, hat aber

trotzdem die Möglichkeit, diese

Skalierung und Einheiten

mitzuführen. Und

in Pandas weiß ich nicht, ob das

inzwischen mit importiert wird,

aber

diese Erweiterung.

Ja, ich habe jetzt

normalerweise auch nicht mehr parat, wie die

Bibliothek, es gibt eine Bibliothek für so Maßeinheiten und so was.

Ich weiß aber nicht genau, wie das

gemacht ist, müsste ich nochmal nachgucken.

Vielleicht können wir das einfach dann

beim nächsten Mal nachreichen oder so.

Auf jeden Fall, da gibt es etwas

und das kriegt man schon irgendwie

alles auch mit dazu geschrieben.

Ja, also genau, das

eigentlich, so wie früher, oder

der Default ist immer noch bei Pandas,

wie Sachen gespeichert werden, das

nennt sich irgendwie Block Manager oder Block Storage

und das sind immer

2D NumPy Arrays

und

die sind halt immer sozusagen, also man

würde eigentlich denken, dass

ein DataFrame, dass jede Spalte

irgendwie ein

eindimensionales NumPy Array

ist, aber das ist halt nicht so,

sondern ein DataFrame besteht

aus Blocks

von 2D

NumPy-Arrays jeweils

zu einem, also unterteilt

nach Datentyp, also wenn ich jetzt sagen habe

ein

DataFrame, der drei Spalten

hat, zwei davon float, einer

Integer, dann besteht das

Ding aus zwei NumPy-Arrays, eins

mit Integer und eins mit float,

das halt zwei Spalten hat.

Da muss man jetzt natürlich aufpassen, von welcher

Seite man drauf guckt, weil

aus Pandas Sicht ist das erstmal

eine Liste von Pandas Series,

Da haben wir auch noch nicht drüber gesprochen, was das ist.

Die Abbildung als

NumPy-Arrays ist natürlich

dann irgendwie die technische zugrunde

liegende Abbildung.

Ja, genau. Das ist halt,

eigentlich sollte das egal sein.

Sollte man sich eigentlich keine Gedanken darüber machen,

sondern, genau, eigentlich ist eine Series halt quasi,

kann man es verstehen als Spalte oder eben Vektor,

eindimensionale

Datenstruktur mit halt vielleicht noch einem Index dran.

Aber

so wird es halt nicht gespeichert und

das Blöde ist, dass diese

Abstraktion halt auch so liegt, weil

wenn man jetzt

zum Beispiel eine Spalte hinzufügt zu einem DataFrame,

dann hat man das Problem,

dass dadurch,

dass jetzt, wenn man schon ein paar

Float-Spalten da drin hat und man

fügt jetzt eine dazu, dann

geht das ja nicht mehr wirklich,

sondern dann müssen die kompletten Daten alle

kopiert werden dafür.

Und wenn man jetzt in der Schleife

irgendwie Spalten hinzufügt oder so, dann

kann es sein, dass einem der Speicher platzt und man weiß überhaupt

nicht warum. Das heißt, man muss im Grunde wissen,

dass Pandas das so macht

und dann gibt es dann immer so Tipps,

die dann sagen, wenn man da irgendwie viele

Spalten hinzufügt, dann immer erst mal die einzelnen

Spalten sammeln und dann hinterher alle

zusammenfügen oder so, nicht

irgendwie auf einem großen Data-Frame eine Spalte hinzufügen,

dann noch eine hinzufügen, das ist schlecht

und das sollte eigentlich natürlich,

das sind so Schwächen bei Pandas, das sollte ja eigentlich

nicht, das sollte einen gar nicht interessieren, wenn man das

benutzt. Dummerweise muss man solche

Sachen aber dann vielleicht doch wissen, weil

man halt dieses Problem da an der Stelle

noch hat. Aber das kann sein, dass das jetzt

alles demnächst besser wird oder das ist jetzt

mit der letzten Version ist es halt schon ein Stück

besser geworden und da sind halt

die einzelnen Spalten haben ihren eigenen Typ und ihre

eigene Speichergeschichte und dann ist das alles

nicht mehr so ein Problem.

Aber ja, das ist vielleicht auch noch interessant.

Also Pandas ist gedacht für so Daten,

also Small Data kann man

quasi sagen, also

Daten im Bereich von so ein paar

Gigabyte, also einstellig Gigabyte,

weil halt da fast

alle Operationen dazu führen, dass das irgendwie kopiert wird,

kann es sehr schnell sein, dass man halt

irgendwie auch, dass man halt 5 oder

vielleicht sogar bis zu 10-facher der

Datenmenge, die tatsächlich auf der Platte landet oder so,

man dann als Hauptspeicher braucht, weil

ja, man kopiert ein paar,

äh, man fügt ein paar Spalten hinzu, transformiert

ein bisschen was und dann schon hat man irgendwie einen 5-fachen Hauptspeicher

verbraucht.

Und daher ist es halt nicht so richtig effizient.

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

Aber, äh, also für

größere Sachen kann man Pandas nicht so super

benutzen, aber

für diese kleinen

Datenmengen ist es halt sehr, sehr cool, weil es super

interaktiv ist und da auch viel Optimierung

reingesteckt wurde, die Operationen

halt auf so, auf den Datenmengen halt

schnell zu machen, sodass man halt

oft dann nicht ein paar Sekunden warten muss,

sondern eigentlich immer nur so ein paar hundert Millisekunden

und das,

gerade wenn man das jetzt zusammen mit

Jupyter Notebooks halt

interaktiv in einem Browser verwendet,

ist es halt sehr wichtig, dass man da nicht irgendwie, wenn man

irgendwas ausführt, halt lange warten muss, sondern

man drückt irgendwo drauf, es wird ausgeführt

und man sieht ein Ergebnis und

kann damit direkt weiterarbeiten.

Genau.

Ja, vielleicht noch mal kurz

in Jupyter Notebooks, also tolles Tool tatsächlich,

wenn man sich so gerade so Daten aus der

Wissenschaft angucken will, einfach ein

DataFrame laden, da die ganzen Daten reinkloppen

und dann mit Matplotlib und Seaborn

irgendwo direkt live immer

Änderungen verfolgen können. Ja, ich würde fast noch

sagen, also der ganz, ganz klassische

Workflow ist, man ruft einmal

Describe auf, dann kriegt man so einmal die

Rahmendaten, Streumaß und

Lagemaß auf dem Dataframe

und dann kriegt man direkt alle statistischen

Auswertungskennzahlen, die man so kennt.

Genau, .describe, Klammer auf Klammer zu,

fertig, dann kriegt man erstmal einen groben

Überblick über seine Daten. Dann kann man

natürlich auch in die Daten direkt reingucken mit

Head und Tail und

das ist in meiner Erfahrung auch das, was man

bei einem neuen Datensatz als allererstes

mal macht, um sich anzugucken, womit

arbeite ich denn überhaupt?

Und spannenderweise, wir waren eben bei Datenimport, da ist noch eine Sache, meine Lieblingsfunktion ist an der Stelle tatsächlich Import from Clipboard.

Also man kann tatsächlich, wenn man gerade irgendwie mal in Excel war oder in OpenOffice und was kopiert hat, das in Pandas DataFrames direkt wieder einladen.

Das habe ich allerdings noch nie ausprobiert in Jupyter Notebooks. Ich weiß nicht, ob der das hinkriegt, aber ich wüsste jetzt auch erstmal nicht, was dagegen sprechen sollte.

Nö, das kann gut sein, dass das funktioniert, ja.

Also kann man sich halt auch ganz kleine

Datenchunks, kleine Tabellen direkt

aus der Zwischenablage

in seinen Data-Frame reinladen.

Das heißt, wenn wir jetzt von diesem

Gigabyte-Bereich liegen, ich glaube, für wissenschaftliche

Anwendung müsste das in den meisten Fällen noch relativ

ausreichend sein. Ja, ja, absolut. Also das ist sowieso

so, die allermeisten Leute haben

nicht mehr Daten. Also für die allermeisten

Leute reicht es aus. Wenn man mehr

hat, dann weiß man das und dann kann man auch was anderes

nehmen.

Ja.

Ja, aber stimmt, wir hatten

eben noch gar nicht genau, vielleicht sollten wir da so ein bisschen

systematisch auch nochmal kurz reingehen, was

also Pandas,

genau, das hat auch was damit zu tun,

wo der Name herkommt, also Pandas steht

eigentlich für Panel Data oder

das war halt auch mal das, was halt so in der Finanzwelt

wo Leute von gerätet haben, von Panel Data

und damit meinen sie

dann halt oft Excel Sheets

irgendwie oder mehrere davon

und das kann Pandas auch, ist

aber irgendwie nicht mehr so, also es gibt auch noch

es gibt halt einmal Series, es gibt Data Frames

das ist halt sozusagen die zweidimensionale

Tabelle

irgendwie, Serious ist eindimensional

und dann gibt es auch noch Panels, die sind halt

dann mehrdimensional

und die werden aber eigentlich nicht mehr

verwendet, glaube ich, oder

wurden eigentlich nie so wirklich

viel verwendet und das ist, glaube ich,

überliegen die Leute auch gerade, ob sie das irgendwie wieder

rausnehmen, weil es eigentlich ziemlich sinnlos ist

und der Hauptnutzen irgendwie bei den Data Frames

ist.

Genau.

Daher kommt der Name.

Es ist ein bisschen blöd, wenn man danach googeln will

und dann hat man Tierbilder.

Aber wir haben immer wieder Tierbilder

dabei. Auch interessant, dass das Vorbild

für Pandas ist R,

denke ich mal.

Das ist mit Googeln auch nicht viel einfacher, aber

genau.

Ja, ich weiß nicht,

du hast auch schon mal mit A gearbeitet,

Simon.

Wie kann man

das eigentlich miteinander vergleichen?

Und es ist ja vielleicht auch ganz interessant zu sehen, wo das herkommt.

Ja, also ich habe in meiner Forschungszeit sehr viel zwischen R und Excel hin und her gewechselt.

Und tatsächlich muss ich sagen, die R-Data-Frames, die den Pandas-Data-Frames sehr, sehr ähnlich sind,

die hatten irgendwie so zwei, drei zentrale Vorteile gegenüber Excel, weswegen ich irgendwann komplett gewechselt bin.

Einer ist sicherlich, dass die Data-Frames immer rechteckig sind.

Also man kann nicht eine Spalte mit weniger Daten füllen als die nächste Spalte.

Es muss zu jeder Zeile immer für jede Spalte auch einen Wert geben.

Also es gibt für jeden Index irgendwie keinen Error.

Genau, wenn es ein Not a Number ist, ist das okay, aber es muss auf jeden Fall irgendeinen Eintrag geben.

Das führt dann dazu, dass man keine Überprüfung mehr machen muss, wie lang ist denn meine Spalte gerade, in der ich bin.

dann gibt es bei DataFrames grundsätzlich auch Typen je Spalte.

Das ist in Excel nicht so.

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

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

Und in DataFrames, dadurch einfach, dass man eine Series pro Spalte hat,

hat auch eine Spalte immer nur einen Typ.

Und das Dritte, was ich an Data Frames unheimlich zu schätzen wusste, waren, in A heißen die Factors, in Pandas heißen, glaube ich, einfach nur Categories oder haben gar keinen speziellen Namen, dass, wenn man kategorische Daten hat, die erstmal als Text erscheinen, sowas wie, weiß ich nicht, Beispiele.

Blau, Rot, Gelb als Farben in einer Spalte.

Dass die in dem zugrunde liegenden Datenformat

erst mal sowas wie Integer sind

und entsprechend auch relativ schnell

zum Indizieren benutzt werden können,

aber für die Anzeige, für das Menschenlesbare

wieder als Rot, Gelb, Grün, Blau dargestellt werden.

Okay. Wie macht Pandas das? Als Dictionary dann?

Das war lange, also in Pandas heißen die Dinger Categorials und das wurde dann quasi intern irgendwie auf Integers abgebildet. Man hatte die einfach durchnummeriert und dann war das halt, was halt natürlich auch viel weniger Platz braucht als Text, aber jetzt auch glaube ich mit 0.24 ist es jetzt so, es hat auch einen eigenen Datentyp bekommen, sodass es halt jetzt auch so ein First Class Citizen im Grunde ist.

so vorher war es halt auch mal so, naja,

es sind komische Dinge passiert. Ich hatte zum Beispiel mal

irgendwann

mit Categoricals

auch so ein Problem. Ich habe da irgendwie

größere Data Frames irgendwie zusammengebastelt

und dann ist mir

irgendwie so regelmäßig der Hauptspeicher explodiert

und ich wusste nicht warum, habe ich dann auch einen Bug

irgendwie bei Panas gefeilt und

der war dann ziemlich lange offen.

Das hatte halt auch damit zu tun, dass es nicht

irgendwie nativ irgendwie da drin war,

sondern das war halt mit den anderen IntelliJer-Geschichten

irgendwie verknuselt und

Ja, das ist schrecklich.

Ja, aber genau, das ist natürlich eine sehr nette Sache,

wenn man das halt so machen kann.

Ja, das heißt, man sieht halt den Text in der Tabelle,

aber in Wirklichkeit speichert man halt viel weniger Daten,

halt nur eine Zahl.

Ja, praktisch.

Wie schaut man sich denn so Daten dann an?

Also ich musste ja irgendwie eine Struktur bringen.

Ich habe jetzt irgendwie ganz viele Spalten irgendwie mit Zeilen

in meinem großen rechteckigen Datenfeld

drin oder sowas und ich möchte jetzt irgendwie

die kombinieren.

Also man kann auch direkt auf dem,

also das benutze ich tatsächlich ziemlich gerne,

man kann sagen,

also DataFrame, man kürzt es normalerweise immer ab

mit df, also das

Standardobjekt, was man dann halt sozusagen hat,

heißt einfach df

und da kann man einfach sagen df.plot

und dem halt noch so ein bisschen Parameter

mitgeben und dann

plottet das halt direkt.

Dann kannst du ja dann Daten anzeigen,

die du dann reingegeben hast, also

die Visualisierungsebene dann damit quasi.

Genau, genau. Und im Notebook sieht man halt auch dann direkt irgendwie

quasi grafisch was.

Standardmäßig ist es dann halt ein Matplotlib,

aber man kann halt das auch,

dieses Plotting-Backend von Panda

sozusagen austauschen, also es ist halt so pluggable und man kann

das austauschen und man kann halt auch Bokeh

zum Beispiel nehmen oder

weiß gar nicht, ist auch noch viel

andere. Ich habe Plotly

schon gesehen in dem Zusammenhang

und Seaborn ist ja im Prinzip

Matplotlib nochmal ein bisschen erweitert

kann man da auch reinpluggen.

Genau, so dass es halt, man hat halt

immer, kann es dann anders aussehen

lassen, so dass zum Beispiel bei Bokeh oder

Plotly ist es halt so, wenn man dann sagt

DF Plot irgendwas, dann kann man

das, dann ist das, was man sieht,

dann halt auch scrollbar zum Beispiel,

man kann da drin zoomen oder so,

was man bei einem Matplotlib-Bild jetzt nicht machen kann,

weil da ist einfach, das ist quasi dann halt so ein

statisch rausgerendertes PNG oder so

und dann, wenn man da reinzoomt,

wird es nur pixelig, aber man sieht

nicht mehr, während halt bei

eben dieser, bei Plotly

oder so hat man dann, kann man, wenn man

reinsucht, sieht man einfach an der Stelle mehr

und das, man muss

an dem Plotaufruf eigentlich

nichts ändern, sondern man tauscht einfach nur das

Backend aus und

ja, das ist schon sehr nett und das verwende ich tatsächlich

oft irgendwie

um Sachen zu visualisieren.

Wenn man so einmal kurz schnell so einen Überblick bekommt.

Wie suche ich mir die Daten denn aus? Also wie kopiere ich

denn da irgendwas von den Daten, wenn ich ja so ganz viele

Spalten und Teilen habe? Also wenn

man gar nicht weiß, wie man anfangen soll,

wenn ich mich richtig erinnere,

macht Plot standardmäßig einfach ein

Pair-Plot. Alles gegen alles.

Dann sieht man schon mal, wie sind die Daten zueinander

verteilt. Dann kann

man Effekte sehen, wie

auf zwei bestimmten Variablen

ist die Verteilung eher so bimodal.

Man hat zwei Felder von Punkten oder sowas.

Also da kann man schon grundsätzlich

mal sehen, wie sind meine Daten überhaupt verteilt.

Ansonsten

gibt es ja oft eine Fragestellung.

ideellen Welt gibt es im Vorfeld

eine Fragestellung und dann kann man auf diese Fragestellung

hinzuarbeiten. Dann weiß man genau, welche Spalten brauche ich

jetzt gleich. Spaltenzugriffe sind

in Pandas, finde ich, super, super easy

und convenient. Man gibt im Prinzip einfach nur

von seinem DataFrame-Objekt per

.syntax den Spaltennamen an oder in

eckigen Klammern wie bei einem Listenzugriff.

Jetzt muss ich gerade genau überlegen.

Doch, da geht der Spaltenname

auch. Ja, es gibt

zwei Interfaces. Es gibt halt mit

man kann halt entweder den Namen

nehmen oder man kann halt auch den numerischen Index

nehmen. Das ist Log

und I-Log, glaube ich, sind die unterschiedlichen

Funktionen, die man da aufrufen kann.

Aber also ich würde auch eigentlich

immer eher, also mit den Indizes

ist eine ältere Geschichte und

ich würde eher die Namen immer nehmen, weil das

klarer ist, was da eigentlich gemeint ist.

Und die werden dann irgendwie mit GroupBy irgendwie so vorsortiert

oder sowas und dann gibt es irgendwelche Alternativen und dann kann

man die in Beziehung setzen und dann

alles plotten? Also erst mal

hat man Zugriff auf seine tabellarischen

Daten. Und da kann man sagen,

ich möchte jetzt Spalten A,

B und E plotten

auf einer X-Achse,

die ist in Spalte D meinetwegen.

Aber nur die roten.

Oder die roten und die gelben vergleichen. Genau.

Das ist dann der zweite Schritt,

dass man anfängt, vorher zu

aggregieren. Man kann dann

überlegen, will ich

nur bestimmte Gruppierungen haben?

Es gibt Funktionen, die heißen GroupBy.

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

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

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

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

Das ist spannend für die ganze Anwendung, wenn man irgendwie so kategorisierbare Daten mit verschiedenen Merkmalen hat und man dann bestimmten Merkmalen, bestimmte Wahrscheinlichkeiten zuordnen will, also mehrere Merkmale hat, also keine Ahnung, Leute ab zwei Meter und trotzdem unter, weiß nicht, 70 Kilo und welche Wahrscheinlichkeit haben die für bestimmte Dinge?

Genau, da kommen wir in einen anderen Bereich so ein bisschen rein und das ist Indizierung auf Basis von Boolean Werten. Also man kann jetzt zum Beispiel sagen, ich möchte aus meinem Datensatz eigentlich nur alle Zeilen auswählen, in denen Spalte A, was zum Beispiel die Höhe sein könnte, sagen wir Höhe eines Menschen kleiner als 1,80 Meter und größer als 1,60 Meter ist.

Und dann würde der mir entsprechend einen Slice aus meinem Data-Frame rausgeben, der nur dieser Bedingungen entspricht.

Was wird denn da technisch erzeugt? Also macht der eine Kopie der Tabelle mit diesen Werten oder setzt der halt dann noch eine neue Tabelle daneben mit so Bolian-Werten, ist wahr, ist falsch?

Oder macht der auch so einen Index, den er nur liest?

Gut, also meistens wird tatsächlich, wenn man jetzt irgendwie da irgendwas extrahiert, wird kopiert. Man kann aber auch sagen, dass es nicht kopiert werden soll.

Ja, also das sind meistens diese Boolean, also im Grunde erzeugt das halt eine Spalte, wenn man jetzt zum Beispiel sowas hat, man sagt DF, eckige Klammer auf, irgendwie, DF-Funktionalität ist größer irgendwas und DF-Funktionalität ist kleiner irgendwas.

Bullshit-Ausdruck sozusagen dann halt

irgendwie in eine Spalte verwendet,

wo dann irgendwie in jeder Zeile True oder False

drinsteht. Und dann wird das halt,

wenn man jetzt zeilenweise filtert,

werden halt alle Zeilen,

die halt True sind, rausgesucht

und alle anderen werden halt ignoriert quasi.

Und

ja, ganz genau, wie das

technisch unten drunter funktioniert, weiß ich jetzt aber auch nicht.

Und

ja, das sind halt so,

ich kann mir vorstellen, dass irgendwie so ein

NumPy hat irgendwie als Feature drin, dass man Sachen,

dass man so Masken verwenden kann, aber ich bin mir

nicht sicher, ob es wirklich verwendet wird, keine Ahnung.

Egal, muss man halt nochmal genauer nachlesen.

Ja, und

dann kann man da

irgendwie weitere Dinge mitmachen.

Das ist halt recht

schön, schöne Methode,

um da halt irgendwie Sachen rauszuselecten. Vielleicht kann man

an der Stelle auch mal grad eine

Blogartikel-Reihe erwähnen, das fällt mir da grad ein,

die ich immer

wieder, wenn ich irgendwie Leuten

Panas Erzähler

auch mit erwähne, weil die so toll ist.

Das ist von Tom Augsburger

Ja genau, das heißt

Modern Pandas

und das ist Teil 1

bis, ich weiß gar nicht wie viel es gibt

bis 8

momentan

Kenne ich noch gar nicht, muss ich auch mal reinschauen

Ja

So lernt man immer dazu

Genau und der beschreibt

halt sehr ausführlich, wie das mit dem Indexing

halt eher so aus User-Perspektive, was man damit alles

machen kann, funktioniert.

Und

ja, also gerade wenn man jetzt nicht nur

einen Index hat, das ist auch etwas, was halt

Pandas kennt, was ich von Datenbanken

so nicht kenne. Also Datenbanken bedeuten

Indizes ein bisschen was anderes als halt jetzt bei Pandas.

Man kann halt bei Pandas

auch mehrdimensional Indizes haben und dann da halt

irgendwie kreuz und quer verschachtelte Abfragen

macht. Und da

wenn man das sich so zuerst anguckt,

dann raucht einem da relativ schnell so der Kopf.

Aber wenn man tatsächlich diese

Probleme hat, dann kann das ultra praktisch

sein, wenn man da irgendwie sich mit auskennt

und diese Modern Pandas Serie ist halt eine,

wo man das sehr schön

sehen kann, wie das funktioniert.

Im ersten Artikel werden

glaube ich da irgendwie so halt

diverse Indizie-Geschichten erklärt

und dann gibt es halt einen Artikel

nur zu Method Chaining

und ja, dann

eins zu Indizes

und da wird dann auch nochmal das alte

Interface

gezeigt und halt, was man jetzt

mit dem neuen Interface an Dingen machen kann

und da gibt es halt wirklich verrückte

Abfragen, die man

Also das Ding auf jeden Fall ist wieder

super spannend, was der neueste heiße Scheiß

ist. Was ich jetzt da gekannt habe, ist auch

die einzige Quelle, deswegen habe ich jetzt den Vergleich natürlich

wieder nicht, ist diese Einführung in

Python mit Data Science

oder Data Science mit Python von Jake Wanderplast

Da gibt es auch ein schönes Artikel

zu Pandas drin, das ist auch

frei irgendwo bei GitHub

Ja, die Notebooks

Und sogar als Notebooks, die er alle hoffentlich hat

hat er irgendwie unter MIT-Lizenz da online gestellt

und da kann man auch genau die Sachen als Notebooks

direkt alle ausprobieren. Das ist ein tolles Beispiel für

diese, glaube ich, die einfachen

so die Basissachen drin, dass man so das grundsätzliche

alte Prinzip mal versteht, das man direkt dann mit

Pandas potten kann, ich glaube über den Untergang der

Titanic oder sowas.

Ja, sonst benutzen die

Tutorials oft gerne den Iris-Datensatz.

Da geht es irgendwie um

Blütenlänge und Breite und

das war mir immer ein bisschen sympathischer

als Biologe.

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

Ja, genau. Das ist auch super spannend mit diesen Multi-Level-Indizes.

Da sollten wir gleich auch nochmal vielleicht ein paar Minuten uns Zeit für nehmen.

Für den Moment sei vielleicht auch nochmal erwähnt, wenn man jetzt ein Pandas DataFrame haben möchte

und man importiert das nicht aus einer Datei oder aus der Zwischenablage,

wie komme ich denn überhaupt zu meinem DataFrame-Objekt?

Und du hast eben gefragt,

kann man da vielleicht Dictionaries benutzen?

Ja, kann man tatsächlich.

Also wenn ich in Python schon ein Dictionary habe,

was Keys und als Values Listen hat,

dann kann ich einfach mein DataFrame erzeugen

mit pandas.dataframe oder pd.dataframe,

wenn man pandas als pd importiert,

und da reingeben, mein Dictionary.

Dann macht er automatisch aus den Keys Spaltennamen

und aus den Values, aus den Listen

macht er dann meine

Series.

Hat natürlich zur Bedingung, dass die gleich

lang sind. Ja. Sonst gibt es da

einen Fehler. Ich weiß gar nicht, ob der da mit

NA auffüllt oder ob der

Ja,

außer dass es einen Fehler wirft.

Ich weiß es aber auch nicht. Es gibt auch irgendwie so eine andere Funktion.

Ich weiß jetzt nicht, bei was es genau geht, wenn man halt

so ein DataFrame über so ein NumPy-Array hat oder

sowas, dass der automatisch neue Spalten

erzeugen kann, die er dann irgendwie

fortsetzt. Ich weiß nicht, ob das

linear passiert oder sowas, habe ich irgendwie kurz entdeckt.

Wenn man einfach eine neue Spalte

erstellt dann, wenn man schon drei oder vier hat,

dass du dann, wenn du die fünfte erstellst, einfach

dann neue Werte reinbaut.

Kann sein,

weiß ich nicht so.

Vielleicht habe ich auch wieder irgendwelchen Quatsch erzählt.

Ich weiß gerade nicht genau, was du da

meinst.

Jetzt habe ich das Buch natürlich zu Hause liegen lassen.

Irgendwo nachgeschlagen.

Buch ist aber auch ein gutes

Stichwort.

Und man kriegt ja immer den gut gemeinten Ratschlag, guck doch mal ins Handbuch.

Das Pandas-Handbuch ist tatsächlich länglich.

Es hat 2.900 irgendwas Seiten.

Davon sind rund 900 so die Basisfunktionen, 1.400 nur die API-Referenz und dann nochmal weiterführende Informationen.

Hast du es durchgelesen?

Nee.

So bei aller Liebe, das ist dann doch etwas viel.

aber man kann halt

relativ schnell kapitelweise,

wenn man was ganz Bestimmtes sucht,

da reinspringen. Okay, so als Index.

Es ist auch alles, also verlinktes

wie heißt das, Table of Contents,

Inhaltsverzeichnis, genau.

Verlinktes Inhaltsverzeichnis, man kommt schnell dahin.

Ja, die Dokumentation

von Panas ist auch sehr gut, aber auch manchmal,

also die ist schon etwas

trocken oder so, manchmal muss man sich schon so ein bisschen

ein bisschen quälen.

Vielleicht liegt das an dem Tabellenthema?

Könnte, vielleicht liegt es einfach am Thema.

Sollte man vielleicht eher

irgendwie Schreiner werden oder so.

Das ist vielleicht irgendwie,

ja, das überlege ich mir manchmal.

Das wäre toll.

Ja, aber

genau,

ja,

stimmt, was hatten wir?

Was gibt es für Datentypen, so Serien,

Data Frames, Panels?

Was kann man damit machen?

Ja, so, genau.

Man kann auch sehr viele Dinge,

die man sonst vielleicht mit einer Datenbank machen

würde, damit tun. Und das hat ja auch

so den Vorteil. Also das kann ich auch nur, ich finde

die Art, also das User-Interface

von Pandas ist halt

ziemlich angenehm und ist auch relativ kurz.

Also wenn du mit einer Datenbank arbeitest und

SQL-Statements schreibst, das geht natürlich auch,

aber das ist halt viel

umständlicher.

Und Pandas hat da halt eine sehr schöne

UI

eigentlich.

Und man kann viel damit machen, was man halt

auch mit einer Datenbank normalerweise tun würde. Und insofern

kann ich das auch nur empfehlen, wenn man jetzt irgendwie so ein Datenbankproblem

hat. Man kann auch irgendwie die komplette Datenbank,

meistens sind die ja nicht so groß, auch irgendwie in Pandas

sich reinholen oder als Data Frames aus der Datenbank

ziehen und dann da irgendwelche Dinge machen

und dann schon mal, wenn man dann weiß,

wie es geht, dann kann man es hinterher auch in SQL machen.

Aber vieles von dem

lässt sich auch locker in Pandas mal ausprobieren,

weil Pandas hat ja eben auch solche Funktionen wie

man kann Joins machen,

man kann halt Data Frames Merge, also da heißt das

dann, also ich glaube, da verwendet man

eher einen Aufruf Merge oder so, aber im Grunde

macht es dann halt auch ein Join zwischen

zwei DataFrames. Dann kann man angeben, auf welchen

Spalten gejoined werden soll und solche

Dinge. Und

genau, eben all diese Group-By-Geschichten.

Gibt es tatsächlich so eine Funktion, wie man

eine Datenbank in DataFrame bekommt und

andersrum, wie man eine DataFrame in irgendeinem Datenbanktyp

speichert? Ja, ja.

Also für alle Datenbanken gibt es da Adapter,

mit denen man die Daten noch auslesen kann.

Genau, also diese Import-

Export-Geschichten. Also wir haben

nur über Import gesprochen,

aber Export gibt es halt auch für

alle diese Datentypen. Warum schreibt dann

irgendjemand noch SQL-Statements?

Ja doch, also

manchmal, es kann schon sinnvoll

durchaus

sinnvoll sein. Also wenn du an der Datenbank ja auch

irgendwas manipulieren willst an Werten, dann musst du es ja tun.

Du kannst ja gar nicht, kannst auch

ein Pandas machen, aber dann hast du das Problem, musst es ja irgendwann wieder

zurück in die Datenbank schreiben.

Dann man klöscht eine neue Datenbank.

Ja.

Und gegebenenfalls

ist das, was du in deinem Speicher bearbeiten

kannst, auch

kleiner als das, was

in der gesamten Datenbank ist. Das heißt,

beim Import würdest du schon nur einen Teil

aus der Datenbank nehmen, kannst damit

aber dann relativ komfortabel

rumspielen.

Tatsächlich, der Befehl

ist Join, auch

in DataFrames. Ich verwechsel es auch immer wieder,

deswegen habe ich gerade mal kurz nachgeguckt.

Und es gibt noch Concatenate,

da kann man aus einem DataFrame

Spalten in ein anderes

reinziehen.

Ja, und dann, genau,

solche, eben, es gibt

so Datenmanipulationsgeschichten,

eben Join, Merge,

dann gibt es noch

solche Sachen wie,

genau, das ist auch schwer

zu erklären, wenn man das jetzt nur hört,

fürchtig,

sowas wie Pivot,

Unpivot, Melt,

Stack, Unstack,

sehr praktische Geschichten, aber ich weiß jetzt ehrlich gesagt nicht genau,

wie ich das erkläre.

Ja, du kannst, also wenn du,

Okay, ich versuche es mal einfach, wenn du jetzt

du machst im Grunde aus einer

aus Dingen, die in einer

Spalte stehen, machst du mit

Pivot irgendwie zusätzliche Spalten.

Also ich bin

gerade völlig auf den Kopf gefallen. Ich habe es natürlich mit der

Transformation gerade verwechselt.

Transpose, ja.

Das ist relativ einfach, aber

Pivot macht schon so ein bisschen kompliziertere

Dinge. Das aggregiert irgendwas zur besseren Auswertung.

Ein Widerfall, doch?

Nee, das, das, ja, also

manchmal hat man Daten halt in einem Format,

in dem man schlecht plotten kann.

Und manchmal braucht man halt Dinge, die

in einer Zeile, die irgendwo in einer Zeile stehen,

die möchte man als Spalte haben, um dann halt die Spalte

besser plotten zu können. Und dafür fällt man dann auf

Pivot. Und dann, genau,

die umgekehrte Funktion dazu ist Melt.

Und

die, aber eigentlich

noch allgemeineren Funktionen, die funktionieren dann eben

auf so Multilevel-Indizes

und halt Stack und Unstack.

Aber das kann auch sehr schnell

ein bisschen überfordern.

Also ich kann sagen, so aus dem

Biologenalltag, dass ich Pivot und Melt

nie benutzt habe. Einfach

weil die vielleicht auch

zu viel Magie im Hintergrund noch machen können.

Stack und Unstack aber

sehr häufig, weil

in der Realität

sind, wir hatten ja eingangs über die

Excel-Tabellen gesprochen, die nicht

immer ganz maschinenlesbar sind.

Es gibt noch den Zwischenwert, wo

die zwar maschinenlesbar sind, aber

mehrere Level von Indizes haben und wenn die mehrere Level von Indizes haben, man könnte

sich das zum Beispiel vorstellen wie, ich hatte eben noch ein Beispiel im Kopf, sowas

wie Klausurnoten nach Semestern in zwei verschiedenen Gruppen, sagen wir mal Biologen versus Chemiker

oder sowas, wie die in der Chemieklausur abschneiden im ersten Semester, im zweiten Semester.

Und dann hat man diese Gruppierung einmal, zu welcher Gruppe gehören die Personen an,

aber dann hat man auch für jede Zeile im Prinzip eine spezifische Person.

Das heißt, mehrere Personen teilen die gleiche Gruppe, also Biologe oder Chemiker,

aber jede Person hat eigene Noten in Semester 1, in Semester 2.

Wenn man das jetzt, jetzt muss ich kurz überlegen, in welche Richtung man das stacken würde,

dann würde man im Prinzip sagen, ich schreibe jetzt jede Person einzeln als Zeile auf

und habe eine neue Spalte, wo die Gruppe nochmal als sich wiederholender Wert mit drin steht,

sodass ich wegkomme von, ich habe im Prinzip zwei Zeilen, die jeweils vier Unterzeilen beinhalten,

Ich habe einfach acht Zeilen, wo in jeder dieser Zeilen die Gruppe nochmal explizit drinsteht.

Das macht es dann einfacher, nachher Gruppierungen zu machen.

Außerdem könnte man dann mit Unstack in die andere Richtung wieder sagen,

ich möchte das jetzt gar nicht nach den Gruppierungen unstacken, sondern nach Semestern zum Beispiel.

Und dann tauscht man plötzlich die Spaltenidentitäten.

Aber ja, also Tabellentransformationen einfach nur in einem Audio-Podcast zu erklären, ist sehr schwierig.

Genau. Ich weiß

gar nicht, ob es zu dem Stack-on-Stack oder

so Thema halt auch ein

Modern Pandas Artikel

gibt. Ich fürchte nein. Schade.

Ah ja, muss man einfach mal nach...

Also, ne, ich verlinke da einfach mal

einen Artikel zu, wie das so aussieht.

Wenn man das sieht, ist es eigentlich, dann kann man

es deutlich besser verstehen.

Ja, genau. Das sind so die Dinge, die

man damit dann tut.

Ja.

Ja, vielleicht nochmal dieser Pivot kurz,

das wart ihr gerade kurz dabei, das sind wir kurz

abgeschreibt. Also was

macht man damit jetzt genau? Also ich kenne das irgendwie jetzt auch aus Excel,

dass man irgendeine Auswertung hat, man hat dann irgendwelche

Datenblätter oder sowas und dann möchte

man dann irgendwelche Aggregate

irgendeinem Endnutzer

auf einem Auswertungs-Dashboard

zur Verfügung stellen und da wird dann

irgendwas zusammen gerechnet.

Ja, Excel genau kann ja auch

sowas, so Pivot-Tabellen.

Also ich habe hier gerade mal das

Data-Science-Cheat-Cheat-Pandas

offen. Können wir auch nachher verlinken.

Und da steht

im Wesentlichen drin, dass

Pivot Table, wie gesagt, ich habe es noch nie benutzt,

aber dass es

eine Pivot-Tabelle macht,

anhand von

einer Spalte gruppiert

und dann aber über andere

Spalten eine Funktion aufruft.

Das kann zum Beispiel sowas sein wie Mittelwert oder

eine Summe oder

nahezu beliebige Funktionen.

Möglicherweise habe ich das auch nie benutzt, weil ich die Excel-Funktion nie benutzt habe.

Was ich allerdings öfter benutzt habe, ist die Funktion Apply.

Und Apply erlaubt einem jetzt innerhalb eines Data Frames auf Basis einer Achse sozusagen eine Funktion auszuführen.

Das kann auch wieder nur Mittelwert oder Standardabweichung sein.

Das können aber auch komplexere Funktionen sein.

Und also für die, die vielleicht schon Hintergrund in R haben,

da gibt es T-Apply und L-Apply für Zeilen, Spalten und was weiß ich nicht alles.

In Pandas DataFrames gibt es im Wesentlichen Apply und man gibt die Achse an.

Also soll das auf Reihen, auf Spalten agieren.

Und dann gibt man eine Funktion an und die wird dann entsprechend für eine komplette Spalte

oder eine komplette Zeile ausgeführt.

Ja, das ist vielleicht eben genau, das ist auch noch ein ganz wichtiger Punkt, den wir noch gar nicht erwähnt haben, dass man, man kann, was man nicht tun sollte, ist über Data Frames iterieren und dann in der Vorschleife da irgendwelche Dinge mitmachen, das könnte man sich auch vorstellen, dass man das so tut, weil das, wenn man das, wenn man aus Python kommt, dann macht man das ja mit Listen normalerweise so, aber das geht halt nicht, oder das geht schon, ist halt nur dann sehr, sehr langsam, während halt, wenn man jetzt Apply aufruft, dann ist das halt ziemlich schnell.

weil unten

drunter, weil eben

Vorloops in Python sowieso langsam sind

und man dann eben keine Vorloop machen muss,

sondern das läuft halt alles irgendwie

in den entsprechenden, also kommt

je nachdem, wie der Datentyp ist,

aber möglicherweise halt landet das in

einer dieser optimierten Vortragsbibliotheken,

die unten drunter unter der Lampe liegen

und es ist halt auch so, dass es dann

in gewisser Weise schon parallelisiert wird

oder halt diese, ich weiß jetzt gar nicht,

wofür SIMD steht,

diese Instruktionssets, diese

Single Instruction Multiple Data.

Ah, okay. Ja, genau.

Super. Dankeschön.

Ja, man spricht da auch von

Vektorisierung. Also man

kann halt

mit einem Taktzyklus halt

mehrere

Operationen ausführen, weil

man hat so super lange Register.

Weiß ich nicht, vielleicht 512

Byte oder so.

Und da sind dann halt viele,

wenn man jetzt Integer hat, 4 Byte

Werte drin und die werden dann halt

alle addiert gleichzeitig oder

multipliziert oder sowas.

Und man zerlegt halt ein komplettes

Array sozusagen, auf dem man dann

irgendwelche Dinge macht, halt in diese Blöcke

und braucht dann halt viel weniger Takte,

als wenn man da einen Vorluft drüber machen würde.

Ja, und das

macht Sachen super schnell.

Man hat halt irgendwie so

Python-Interface und ein Jupyter-Notebook,

das sieht dann halt so aus, als wäre man

super high-levelig, aber wenn man eine Operation macht,

kann es sein, dass dann tatsächlich etwas sehr, sehr

Optimiertes passiert und es sehr schnell

ist und wenn jemand da hingehen würde,

würde er es in C schreiben, ist er möglicherweise

deutlich langsamer, wenn er

nicht genau weiß, was er tut.

Und das ist natürlich für viele

Leute auch total überraschend.

Und das ist auch eine sehr, sehr, sehr, sehr schöne Geschichte.

Aber ja, man muss halt

auch so ein bisschen eine komische

Syntax dafür halt in Kauf nehmen.

Man kann halt nicht mehr For-Loops machen, man muss halt

immer Apply schreiben und dann halt

eine Funktion übergeben. Oft übergibt man dann halt so anonyme Funktionen.

Schreibt dann Apply und dann Lambda, X

und dann kriegt man halt irgendwie einen Wert übergeben,

macht dann damit irgendwas.

Comprehensions oder sowas

kann man auch vergessen, genau, das selbe Problem.

Genau, das geht alles nicht mehr.

Man schreibt halt alles nur noch

ja, quasi,

man schreibt eigentlich fast alles in Apply. Ich weiß gar nicht,

ob es da noch andere Funktionen gibt, die so ähnlich sind wie Apply.

Naja.

Nee, das ist eigentlich

immer Apply, ja.

Ja, und

dann chainet man halt die Sachen hintereinander.

Man kann halt,

diese Methode liefert dann halt

das Ergebnis von dem Apply zurück, dann

ruft man darauf wieder was anderes auf und dann

hat man halt eine ganze Reihe von so hintereinander

gechainten Apply-Aufrufen unter Umständen.

Und ja.

Das ist auch

witzig. Fällt mir gerade noch

zu dieser Vektorisierungsgeschichte ein.

Früher

haben auch Leute irgendwie

erzählt, naja, ach,

das mit der Parallelisierung,

das ist ja alles gar kein Problem, wenn wir jetzt viele CPUs haben,

so irgendwie die

Steigerung der Taktfrequenzen war ja dann irgendwann auch schon

vor längerer Zeit irgendwie vorbei,

mehr oder weniger, und man muss halt, man kriegt halt

mehr Prozessoren, also Moore's Law ist halt noch nicht

wirklich weg, weil sich das eigentlich auch nur auf

die Transistoren, nicht auf die Geschwindigkeit

als solche irgendwie bezieht.

Aber

dann hieß es halt so, naja, das ist kein Problem,

wenn man mehrere Prozessoren hat, da gibt es dann bestimmt Compiler,

die das automatisch parallelisieren oder so.

Nee.

Ist nicht passiert, wird auch nie passieren.