Transcript: Das Python Data Model

Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python-Podcast Episode 58.

Wow, 58.

Ja, gar nicht so schlecht, oder?

Über was reden wir heute? Über Flur und Python. Hi Jochen.

Jo, hallihallo Dominik. Herzlich willkommen.

Und hi Johannes.

Johannes, hi.

Schön, dass du da bist.

Ja, schön, dass ich da sein darf.

Wir hatten dich ja schon ein paar Mal hier, habe ich gehört.

Ich war schon, ich glaube ein- oder zweimal oder so ungefähr dabei.

Ja, glaube ich auch. Anderthalb oder so.

Also wir wollen heute bei einem Buch sprechen, Flo und Peißen von Luciano Ramalho.

Richtig ausgesprochen? Ich weiß nicht genau.

Ja, oder das haben wir uns so ein bisschen als Vorlage hergenommen.

Ich würde eher denken, wir, also es wurde, es wurde, wir hatten, uns erreichten, genau, uns erreichten irgendwie Zuschriften, die sagten, ah, mach doch mal ein bisschen was mehr für Anfänger und irgendwie mehr.

Und dann hast du dir das tollste Buch ausgedruckt, wo du dann.

mein Lieblings-Python-Buch

und dann dachte ich,

da kann man ja vielleicht mal so ein bisschen durchgehen.

Ich lese mal kurz aus dem Buch vor,

weil du sagtest, du bist ein Anfänger.

If you are just learning Python,

this book is going to be hard to follow.

Not only that, if you read it too early in your Python-Document,

it may give you the best and every Python-Script

and level-special-message

and metaprogramming-tricks und so weiter.

Also da steht für alle Leute, die es nicht verstanden haben,

es ist kein Anfängerbuch.

Ja, ja, gut, aber wir machen ja jetzt nicht Metaprogramming.

Also Metaprogramming-Zeugs ist da auch drin,

aber das machen wir ja jetzt gar nicht. Noch nicht.

Das machen wir dann nicht. Okay, dann steigen wir leicht

ein mit Datenstrukturen und sowas.

Genau, wir fangen jetzt mit so ganz grundlegenden

Dingen dann an.

Nicht, dass wir Struktur hätten in dieser Folge, aber wir versuchen es heute.

Ja, so ein bisschen. Also wir hatten ja auch schon mal

was zu Dicts gemacht und zu Listen

und ich weiß nicht, ob wir schon Strings hatten.

Hatten wir, glaube ich, noch nicht. Also wir haben

darüber schon öfter gesprochen, aber ich glaube, wir haben tatsächlich noch keine

Folge dazu gemacht. Steht noch auf unserer

Möchten-wir-gerne-machen-Liste.

Aber vielleicht jetzt noch zu News. Gibt es denn was Neues

von Python in der Python-Community?

Ja, also seitdem wir das letzte Mal aufgenommen haben, ist nicht so wahnsinnig viel passiert.

Es ist jetzt auch gar nichts mehr.

Letzte Woche war EuroPython, Jochen.

Ach ja, ja, EuroPython.

Wie war denn die EuroPython?

War gut, hat Spaß gemacht.

Ja, war cool.

Hat sehr viel nette Leute kennengelernt und mit ihnen geschnackt, wie das halt so ist.

Ich weiß aber nicht, ob das einen News-Charakter hat.

Also außer mich persönlich natürlich.

Was ich sehr genossen habe, war tatsächlich Luca Schlanger und der Python-Rapel-3.13-Talk,

der quasi der letzte war vor der

Abschlussrede, wo

man so ein bisschen interaktive Möglichkeiten

sehen konnte von dem, was so möglich ist.

Es war so ein bisschen eine Mischung aus

Eipeißen mit Bund und

man konnte richtig coole Sachen machen und

Beinlings und fancy stuff.

Ist so ein bisschen ein Spaß-Talk gewesen, also er hat dabei Musik gemacht,

hat Euroreq angeschlossen und seine MIDI-Synthesizer

damit bedient. Also genau war mein Ding.

Ja. Fanden die Talks raus und

schaut doch mal rein, ist mit Sicherheit sehr nett.

Und was ich auch ganz gut

fand, war, wir haben alle relativ viel darüber diskutiert,

was Armin Rodenhofer so erzählt hat,

zu

was Scheiße läuft in Python, und zwar das

ganze Packaging-Ding und so.

Das wissen, sind wir ja wahrscheinlich alle derselben Meinung,

dass das da irgendwann mal so ein Tool

geben könnte, das sowas macht wie vielleicht

Cargo für Rust oder so.

Der Meinung möchte ich aber nicht.

Ich bin der Meinung, dass es schön wäre,

wenn wir sowas hätten, aber ich glaube, ich fürchte, dass

wir sowas nicht kriegen können. Okay, aber das ist ja was anderes.

Aber da gibt es auch schon 23 Tools, die sowas

machen. Ja, genau, das ist der Punkt. Armin meinte

dann auch, dann gibt es halt noch ein 24 ist jetzt, aber

das ist so, ist ja altig

XKCD-Comic, ne?

Aber das ist so ein bisschen

vielleicht doch, also

vielleicht sollte man einfach miteinander reden und vielleicht doch

so ein Ding bauen, was dann

übrig bleibt, weil man

braucht halt was, was diese ganze Quark-Sache

wie Pakete managen und

PIP-Tools und

PyEnv und Conda und und und

und und und irgendwie so

schön nutzbar macht, dass

irgendjemand, der das noch alles nicht kennt, einfach mal

so ein Curl macht auf so eine Installation

und dann hat der ein Tool, mit dem

das alles geht. Das wäre schon

ziemlich gut. Also so vom

Paint-Faktor her.

Und immer dann, wenn ich jetzt Leuten versucht habe,

das beizubringen oder versucht habe, bei denen

Python zu installieren oder auf so einer

Schulung irgendwie kleine Sachen mit denen machen wollte oder

die zum ersten Mal so ein Notebook in die Hand nehmen wollten

oder irgendwie

irgendwas anderes, das war immer Schmerzen

damit verbunden.

Und da ja Rust gerade so ist.

Nein, eigentlich ist das ganz einfach.

Also du musst folgende Sachen installieren.

Es ist wirklich nur eine sehr kurze Liste.

Also erstmal brauchst du Build Essentials

und dann brauchst du die ganzen Abhängigkeiten

und libjpeg und libjpeg98

und libjpeg2k

und dann musst du PyRAMP installieren

und dann bist du schon fast so weit.

Und dann Apfel und eine Banane

und wie Jochen sagt, den ganzen Dschungel.

Und ja, also ich habe am Sprint

und für PyRAMP so ein paar Sachen installiert,

weil ich es kompilieren wollte.

Es hat tatsächlich drei Stunden gedauert,

bis es kompiliert ist auf meinem Tool.

langsam sieht. Klasse.

Aber so ist das manchmal.

Ja.

Ja, also ich bin mal gespannt.

Also ich bin da, also ich habe ja auch schon

dann irgendwie gehört, was Leute dazu sagen, die sich

mit diesem ganzen Thema schon lange besch und es gab auch schon mehrere Versuche das zu vereinheitlichen und da auch Peps zu etablieren die quasi das standardisieren und die sind gescheitert alle bisher Auch das letzte Mal

als jetzt, wie heißt der jetzt noch, einer ganz

bekannter, einer der bekanntesten

Core-Entwickler, der halt auch da irgendwie so ein

Großteam bei Microsoft leitet,

der große Kanadier, wie heißt der noch?

Ne, ich hab den Namen vergessen, keine Ahnung.

Auf jeden Fall, der hat da versucht,

einen Peps zu gemacht, das ist halt hinterher gescheitert, weil

ja, also mit dem Fazit, es geht

nicht. Armin meint, es braucht vielleicht noch ein Jahr,

dann sind viele der Grundvoraussetzungen geschaffen,

die da noch fehlen und das wären gar nicht mehr

so viele. Okay, ich bin gespannt. Also, wenn das

dann funktioniert, dann lasse ich mich überzeugen,

aber das, ja, gut.

Werden wir dann sehen.

Was auch interessant ist, ja, es gibt

einmal diese UV-Geschichte, da gibt's

dann auch noch diese Firma

von Charlie Marsh, die hat ja das irgendwie übernommen,

das zu maintainen, das UV, ne? Ja, genau.

Ja, also genau, UV und

Ray, was war von einem?

Quatscht, genau, und hat nicht

die UV übernommen, sondern Ride, sondern genau.

Die integrieren sich tatsächlich relativ, die reden

auch voneinander und übereinander und so

und die integrieren einander relativ viel und

Ride benutzt das UV statt

Pip-Tools, glaube ich, oder so, ne, über,

dann darüber, das sieht alles gar nicht so schlecht aus

und die Firma, glaube ich, Astral oder so

und die machen ja auch Ruff und das,

was eigentlich auch relativ gut

funktioniert, finde ich. Ja, ja, die machen so

eben ganz viel um Ruff. Gibt's auch

eine Firma hier, also es gibt ja da irgendwie

auch eine schnellere Alternative zu Conda,

Mamba von

Präfix-Dev oder weiß ich nicht,

Wolf Vollbrecht

oder so. Den könnten wir vielleicht auch mal

über diesen Thema fragen.

Ja, du weißt ja gerade, dass du für dich zuhörst.

Ja, und genau.

Und das kommt da auch irgendwie

mit rein.

Und deren

Geschichten sollen da auch irgendwie

mit integriert werden, weil das ist halt unten drunter auch alles

Rust. Und ja, also

okay, es tut sich was. Also insofern ist es schon mal gut.

Ja, mal mal gespannt.

Ja, und ich finde es auch gut, dass man tatsächlich jetzt echt

irgendwann durch ist mit diesem ganzen

Snarft. Und vielleicht also Standards,

also ich mag ja zum Beispiel diesen

Go nicht, weil zu viel Standard und so,

das sind immer zu viele Opinionen und so. Und dann, okay,

dann nutzt man dann doch Black.

Aber

vielleicht gibt es da so ein paar... Moment, das habe ich nicht verstanden.

Was nützt mir nicht? Also ich mag Standards nicht.

Also ich mag es eigentlich nicht, wenn irgendjemand sagt, wie es sein muss.

Wenn jemand so opinionated ist und sagt,

wir machen jetzt, keine Ahnung,

Tabs instead of Spaces, weil

ich will das so.

wenn ich das anders möchte.

Und das nervt mich immer so ein bisschen,

weil das da schon in Python ist,

ist halt dynamisch. Ich kann es mir halt aussuchen, wie ich es mache.

Ja, aber gut.

Also ich meine,

aber würdest du das

sozusagen, würdest du,

du würdest aber nur das konfigurieren wollen, wie es aussieht,

aber du würdest schon Autoformaten wollen.

Ja. Ja.

Okay, ja gut, kann man machen, wie man will.

Ja, also ich meine, aber wenn man jetzt bei Black

dann irgendwie eine Konfigurationsdatei jedes Mal mit schieben muss,

ist halt auch irgendwie ad absurdum, ne?

Ja genau, weil vielleicht gibt es das halt nicht.

Dann musst du halt was anderes nehmen.

Das ist so eine Sache,

die denke ich mir schon lange,

dass eigentlich diese ganze Code-Formatting-Debatte,

die ist doch Quatsch, oder?

Eigentlich sollte doch eine Python-Datei

den AST enthalten

und dann hast du einen Editor

und der kann dir den AST anzeigen

auf eine Art und Weise, wie es dir passt.

Und wenn du die Sachen in grün oder gelb haben willst

oder in Dateien oder Modulen aufgeteilt

oder wie auch immer du es haben willst,

da gibt es so viele Sachen, die man

auf der Ebene machen könnte, aber stattdessen haben wir

Textdateien.

So ein bisschen so,

da müsste mal jemand was machen.

Da kommt dann immer der Einwand,

dann mach doch mal was dagegen.

Das Problem ist halt, wie kriegst

du denn aus dem Ast wieder was,

wenn du jetzt tatsächlich was manuell

anders haben willst. Also du möchtest dir eine

VR-Brille aufziehen und dann hast du

vor dir den einen Balken, den einen

Grafen und hast die Notes, musst du alle durchmaschinen.

kannst du dich auf dein Laufband stellen und hinlaufen.

Ne, also da gibt es

bestimmt Leute, die das so wollen, aber da

ich will ja nicht laufen, ich bin ja ein Softwareentwickler.

Aber

ob du jetzt Tabs oder Spaces hast oder

ob du die Variablen

so oder so nennst oder ob du, keine Ahnung,

viele Dinge,

die du da, ob du Einrückungen

oder Braces haben willst, ja, das ist doch auch völlig

egal. Wenn Leute lieber Braces haben wollen,

dann sollen sie halt sich ihren Editor so einstellen,

dass der die Blöcke mit Braces umfasst.

und umgekehrt, wenn ich

TypeScript schreibe oder so,

dann will ich da nicht überall Braces haben,

dann muss doch mein Editor, muss doch smart genug

sein,

das umformen zu können und warum ist

das so schwierig?

Ja, also ein Grund, der mir jetzt sofort...

Das ist so eine Debatte, die jetzt auch ins Gebüsch führt.

Ja, also ein Grund, der mir direkt so einfallen würde,

ist halt, was ist, weil das hatte ich jetzt letztens

wieder, ist halt, was ist,

wenn ich Dinge anders machen möchte,

als jeder andere?

Du meinst Innovation?

Nein, einfach optisch

Müll, achso, äh, Entschuldigung

Ja, das muss doch dein Editor können

das muss doch eine Einstellungssache bei dir sein

weil am Ende kommt ja der gleiche Python raus Ja aber wenn jetzt sozusagen du kriegst jetzt Code von jemand anders Wie soll denn das so wie ich das sehen will

wie soll der denn dahin transformiert werden?

Das kannst du nur mit Sprachmodellen machen.

In der Standardform geht leicht, aber

der umgekehrte Weg geht halt nicht.

Ich glaube, das geht

in alle Richtungen.

Aber das wäre halt das, was da zu beweisen

wäre. Und ich glaube, dass

die richtige

Darstellungsart eben nicht

Text in

ASCII oder Unicode ist, sondern halt

ein

strukturierteres Modell. Und aus diesem strukturierteren

Modell kannst du dann ja mehr Sachen auch rausziehen.

Ja, gut.

Aber es ist unbewiesen.

Das ist hier so ein, wie gesagt, so ein

Jemand-sollte-das-mal-tun-Projekt.

Ja.

In meiner vierstelligen Liste

der Nebenprojekte ist es nicht auf Platz eins.

Also jedenfalls, ich wollte eigentlich für Standards

an der Stelle sprechen, weil ich tatsächlich finde, dass das

so ein bisschen anstrengend ist. Und es wäre schon gut,

wenn so ein Standard das so löst, dass diese ganzen

Pains und Probleme

eine Lösung haben, die

tatsächlich von allen so

mitgetragen wird.

Das wäre schon irgendwie nice to have.

Also so ein kolorabotives

Spiel.

Zungenbrecher. Ihr wisst, was ich meine.

Ein Koloraspiel? Aber du meinst

jetzt für Codeformat?

Nein. Achso, okay.

Packaging. Und also Installation

und Python generell und Binary verteilen

und Setup und

und Vents und Dependencies

und sowas alles.

Naja, ich habe mir halt diese Diskussion

halt so ein bisschen angeguckt und die

hat mich so ein bisschen hoffnungslos

zurückgelassen, weil

also auch die Leute, die sich damit beschäftigt haben,

die haben das ja auch,

das war ja das Ziel und das Ergebnis war,

geht nicht. Ja, das Problem ist halt,

man will sich aber damit gar nicht beschäftigen.

Doch, doch, da haben sich, oh yeah,

da haben sich viele Leute ganz lange mit beschäftigt.

Ich möchte mich nicht damit beschäftigen, was für

Problem Python beim Package installieren beim

Wendfahrt, sondern ich möchte Packages installieren, die die benutzen.

Ja, aber... Weil ich möchte halt Programme schreiben.

Ja, aber die Frage ist, ist das überhaupt möglich bei einer so

alten Sprache? Geht das?

Und bei Rust, also die Antwort ist,

warum geht das bei Rust, ist halt,

die Antwort darauf ist halt, das geht deswegen, weil das

eine sehr junge Sprache ist. Und weil man all

die Dinge, die man früher bei Python macht, da halt nicht drin hat.

Ja, aber da müssen wir auftämmen.

Ja, aber das Problem ist,

dass man...

Ja, aber ein Großteil von dem Zeug,

das verwendet wird, ist halt älter als 20 Jahre

und macht Dinge, die total komisch sind.

Und dann...

Jochen, was würdest du sagen,

wann ist Rust erschienen?

Wann war das erste Release von Rust?

Ich glaube, das ist etwas mehr als zehn Jahre her.

Irgendwann 2013, 2015?

15. Mai 2015, also neun Jahre.

Ah, gut.

Nicht so schlecht.

Habe ich sogar ein bisschen zu alt geschätzt, ja.

Ja, okay.

Aber also ganz junge Sprache ist es auch nicht mehr.

Nee, aber viel, viel jünger als Python.

Viel, viel jünger, ja.

Ja, gut, das stimmt natürlich.

Wobei Python 3 ist jetzt auch noch nicht.

ist doch auch erst seit ein paar Jahren.

Ja.

Ich dachte, ich habe Zeit

für Python 4. Okay, ja.

Die nächste Version ist

Python 8, oder? Da gab es doch mal so

einen April-Scherz.

So ein Pep, wie die nächste Python-Version heißen sollte.

Und dass man dann immer additiv vorgeht.

Der große Vorteil von dem Versionsschema

ist, dass man alle anderen Versionen einholt.

Das war auch ein lustiger Talk.

Wer ist nochmal der Release-Manager von

13 und 14?

Thomas Waters?

Warp Hots?

Ich meine,

der war auch lustig, weil er meinte nämlich, er möchte

gerne das Versioning von

Python ändern, einfach auf Jahreszahlen

anpassen, dann wäre es halt demnächst

Python 24 einfach,

dann Python 25.

Und dann aber mit drei da vorne, wenn wir drei behalten, dann 325,

weil es im Antikvorson irgendwie Blut wäre.

Da müssen sie sich aber auch noch irgendwelche lustigen Tiernamen

ausdenken, die da dazu passen.

Und bitte alphabetisch aufsteigend.

Ja genau, so ungefähr.

Ja, das war dann die Debatte.

Ja, also es gab viel Spaß und die Talks

sind sicher auch irgendwann bald da und die kann man sich alle

angucken. Es gab ja verschiedene

Tracks, der Data-Track war relativ viel vertreten

wieder. LLMs und so

sind ja wie immer

hoch dabei. Ich hatte

nicht das große Glück, dass ich jetzt da so einen Talk

erwischt hatte, der mich so total faszinierte.

Die waren immer sehr, ich sag mal High-Level, was

auch nicht schlecht sein muss. Aber

ja, bis auf so ein paar Sachen, die halt darum

gingen, so wie man das vielleicht mit dem

Trainieren noch ein bisschen besser hinkriegt oder mit dem Feintunen,

das so ein bisschen effektiver sein kann und nicht so viel

Speicher dafür braucht oder so, aber das müsste

uns eigentlich mal für eigene Episoden irgendwann aufheben.

So was.

Ja.

Was haben wir noch, Jochen?

Ah ja, jetzt wo es um

Europe-Halten ging, was mir eingefallen ist,

stimmt, wir hatten ja letztes Mal auch über die DjangoCon

Europe 2024 geredet

und die Vorträge sind jetzt

online, kann man sich angucken und da bin ich jetzt

gerade dran, die so ein bisschen nach und nach

anzugucken, die ich interessant finde

und da habe ich auch schon interessante gesehen.

Da war auch jetzt diese Woche

ein Treffen der

Python User Group,

Django Cologne User Group wo es dann halt auch einen Vortrag gab Background Tasks was ganz interessant war genau Und ja das klingt alles tats ziemlich interessant

Also da haben sich schon Gedanken über das Interface

gemacht. Salary ID.

Ja, könnte sein, was eine gute Sache wäre.

Ja, und es wäre richtig gut.

Ja, aber

da wollte ich noch sagen, weil du gesagt hast, die ganzen

Talks gucken, das war tatsächlich auch super. Ich mag

dieses hybride Format von Konferenzen.

Auch bei der Europice konnte man halt

abends, wenn man ganz

schon durch war von dem ganzen Tag

und die ganzen Konferenzen live gesehen hat,

sich nochmal den Track von den Sachen, die man verpasst

hatte, bei YouTube auf anderthalbfach angucken

zum Einschlafen oder zum Runterkommen.

Das war sehr cool.

Das heißt, man kann alle Sachen parallel gucken gleichzeitig

oder länger frühstücken, wenn man mag.

Was echt schön ist.

Sehr zu empfehlen, sehr zu empfehlen.

Ja, ansonsten so

in Ermangelung von Dingen, die jetzt mit Palten

so viel zu tun haben, was mich

hier gerade so noch so ein bisschen umtreibt,

ist halt, ach ja, es war bald Urlaub

und ich habe ein bisschen neue Hardware irgendwie mir zugelegt.

Jochen, das ist keine Werbeveranstaltung hier.

Nee, aber was ganz cool ist,

es gibt jetzt tatsächlich,

also dieser Haushalt enthält Computer,

kann Spuren von Computern enthalten.

Und der schnellste Computer in diesem Haushalt ist jetzt ein iPad.

Und ja, also da sind ja diese M4-Dinger drin,

die sind sackschnell, also das ist unglaublich.

Also lässt du das jetzt deine Machine Learning Modelle tunen?

Aber das ist doch kein General Purpose Computer.

Nee, leider nicht.

Argumentiert, dass es kein General Purpose Computer ist.

Ja, das ist blöd.

Aber es wäre voll cool, wenn es ein General Purpose Computer wäre.

Aber es wäre nämlich der schnellste, den ich hätte.

Bau doch einfach die CPU aus.

Ja.

Kannst nicht wandertangluten.

Nee.

Genau, also ja, das ist so ein bisschen so.

Aber das Ding ist tatsächlich, also es gibt das,

M4 gibt es auch noch in keinem anderen Gerät irgendwie von Apple,

also nur im iPad.

Ja, es ist schon so ein bisschen traurig.

Es gab auch eine Tastatur diesmal

mit einer Escape-Taste, sodass

mit der Escape-Taste kannst du eigentlich auf iOS

überhaupt gar nichts anfangen. Sodass halt viele Leute

gedacht haben, es kommt irgendwann ein MacOS

für iPad, was voll cool wäre. Aber

nein, kam nicht.

Und jetzt habe ich ein iPad

und kann es nicht benutzen.

Ein bisschen doof. Aber ja, ansonsten

wirklich sehr schnell.

Ich darf jetzt schnell YouTube gucken.

Ja, genau.

Ich habe noch so eine Platine mitgebracht, die kann man sich

ankleben und mit so einem Magneten

und da kann man so einen Text hin und her laufen lassen.

Und da gibt es so ein Python-Modul, da kann man

dann den Text auswählen.

Und das ist dein schnellster Computer?

Ja, genau.

Ansonsten

gab es noch so ein bisschen irgendwie

LLM-Krams.

Ja, da gibt es doch immer was.

Also Asopik hat tolle neue Modelle

rausgebracht, die ziemlich beeindruckend sind.

Ja, und Mistral

hat jetzt, ich glaube heute

ein neues Modell rausgebracht.

Nemo heißt das, mit einem neuen Embedding.

Die haben einen neuen

Embedder trainiert, der wohl

deutlich besser ist. Das müsste man

sich mal anschauen. Und dieses Nemo-Modell

hört sich auch interessant an. Das ist Zusammenarbeit mit

Nvidia entstanden.

Ein 12B-Modell.

Das ist also etwas

größer als diese 7B-Modelle und das ist

wohl genau so trainiert, dass

das auf einer normalen Grafikkarte

laufen lassen kannst, also auf eine 4090.

Ja, die haben ja alle

11-12 Gigabyte

Hauptspeicher, ja. Genau.

Und das ist wohl auch schon so trainiert, dass es mit

FP8 geht, ohne

Leistungsabfall und das ist natürlich direkt

sehr praktisch.

Ja, ich habe auch letztens gesehen, dass irgendjemand

quasi, also

war das Microsoft

Research? Ich weiß es nicht, ich hatte ein Paper veröffentlicht.

zu einem Modell,

das

die gleiche Performance

irgendwie über viele unterschiedliche,

oder sogar deutlich bessere Performance über viele

unterschiedliche Benchmarks hingekriegt hat,

als GPT-3.5,

aber auf einer einzelnen GPU läuft.

Also auf so einer Consumer-GPU.

Und das war auch zum ersten Mal,

dass das jemand geschafft hat,

GPT-3.5 auf irgendwie so Consumer-Hardware

zu schlagen.

Also das geht jetzt,

du kannst da wirklich auf deinem Rechner zu Hause

irgendwie Sachen laufen lassen, lokal,

auf deiner Grafik, auf deiner

Spielegrafikkarte, die halt irgendwie

das Chat-GPT

vom Anfang halt

deutlich schlagen. Und das ist interessant.

Also, ja, es geht heran.

Ja, da tun sich doch viele Dinge.

Das ist schön, dass da so

auch so völlig

sage ich mal

normale Sachen, ja, dass

sich jetzt hier GPT-4

und 4.0 und so, dass die sich weiterentwickeln

und Cloud Sonnet und so weiter.

Ach so, und das Mistral Nemo-Modell

hat ein 128K

Contacts-Window. Das ist eine Besonderheit.

Das ist auch was Interessantes,

weil die anderen lokalen Modelle hatten ja immer nur

irgendwie 4K oder 8K.

Und das macht doch nochmal deutlich...

Dass sich so ganz normale Sachen weiterentwickeln, dass man eben, genau wie du sagst, Jochen, dass jetzt auf normalen GPUs laufen lassen kann und dass die Modelle größer und schneller und trotzdem skalierbar werden und dass es auch in der Richtung Entwicklung gibt, das finde ich eigentlich ziemlich cool.

Das ist nicht nur so eben in diesen

Hochburgen und in den

Diensteanbietern festhängt,

sondern die Szene ist auch

sehr lokal. Und wenn man sich da mal so dieses,

wenn man sich Hugging Face anguckt, ja, und wie viele

Anleger von Lama es gibt und dann gibt es manche,

wo das Sicherheitstraining

weg ist und einst spricht nur die

Sprache und einst nur diesen, das und jenes kann.

Ja.

Es ist schon schön, dass da was passiert.

Ja, genau. Ja, und die

andere Seite, also OpenAI und so, das ist auch

interessant. Also überhaupt, da wollte ich

auch noch wegen Apple irgendwie

drauf zu sprechen kommen. Die bauen ja jetzt

dann irgendwie die Dinger ein

in iOS

und was eingebaut wird,

ist auch GPT-4.0.

Also du kriegst halt

jetzt, wenn du ein iPhone oder sonst irgendwas kaufst,

wahrscheinlich dann ab jetzt, wenn die neuen Geräte kommen,

kriegst du halt, oder eine neue

iOS-Version, kriegst du halt

quasi die Bezahlversion von OpenAI

irgendwie in deinem

Gerät und

ist halt ein relativ

dicker Deal wohl

und dafür kriegt, also das

ist glaube ich nur ein Gerücht, das ist noch nicht bescheidigt, aber

Er hat noch sogar einen Board-Seed.

Genau, die haben jetzt

Microsoft hat doch die Daten von einem iOS-Mutant.

Haben sie wieder aufgegeben, sind nicht mehr.

Sowohl Microsoft

als auch Apple haben ihren Board-Seed aufgegeben.

Es waren eh nur Beobachtende, aber haben sie beide

zurückgezogen.

Achso, okay, ich dachte eigentlich

das jetzt sozusagen das Gerücht war,

dass das Velfiller irgendwie ins Board von

OpenAI geht, aber...

Ja, haben sie aber wieder zurückgezogen.

Ah, okay. Dann war ich da schon nicht mehr so aktuell.

Aber ich meine...

Es bewegt sich so schnell, dass...

Wahnsinn.

Wenn man hinguckt, ist schon wieder alles ganz anders.

Aber naja, gut, in gewisser Weise

verstehe ich es ja auch. Also das große Problem von OpenAI

ist ja irgendwie, dass sie halt zwar

irgendwie ganz gute Modelle haben, aber

sie haben halt die Geräte nicht da draußen.

Also sie haben halt einen strukturellen Nachteil

gegenüber sowas wie Google oder so. Google braucht das alles nicht.

Die können einfach irgendwie über

Android, haben sie halt

einen riesen Hebel.

Aber OpenAI, wenn sie halt nicht

Partnerschaften mit Microsoft

oder mit Apple haben, dann haben sie halt ein Problem.

Weil, ja,

sonst passiert ihnen das, was halt

irgendwie, keine Ahnung, Slack passiert ist mit

Teams oder so und dann sind sie halt weg.

Ja, insofern

ja, es sind auf jeden Fall interessante Zeiten.

Bin mal gespannt. Aber

4.0 ist auch so gut, also ich finde das hier auch

dauernd, also dass das

wahrscheinlich irgendwie... Aber was denn, Jochen?

Was machst du denn damit? Ja, programmieren.

Achso, ja gut, okay.

Ich gehe nicht in den Flow rein.

Ja, aber auch

Opus, das ist schon... Ja, Opus ist auch

super, also ja, absolut.

Oder so nett. Ja, du gibst halt einfach

so Fragen und das stimmt dann auf einmal

doch eher mehr als früher.

Noch mehr als früher.

Und dann, man kann es halt so steuern,

Habt ihr das irgendwo integriert?

Ja, ja, ID.

Also auch Konsole halt.

Und wenn man halt, dann kannst du halt auch

Pipen mit Cut reinpipen, irgendwas

oder sag dann halt Template

mach einen

PyTest drauf oder so. Und das

ist gut. Gute Vorschläge.

Also die sind nicht immer ganz rein, aber man kann das ja auch

modifizieren. Man kann sagen, ja, ein bisschen mehr

in, ne, ein bisschen mehr Fixtures, ein bisschen weniger dies,

ein bisschen weniger das, wenn man das nicht schon im System

drinstehen hat. Und dann ist das ziemlich

das, was man will. Man kann ja so ein Beispiel geben, wie

hey, und so wie ich das hier gemacht habe,

so dass es ungefähr so könnte es aussehen.

Und dann

fertig.

Ich bin ja mal neidisch, wenn da Leute

das so erzählen, weil ich komme mit

solchen Systemen einfach irgendwie nicht in den

ich komme nicht in den Flow.

Vielleicht muss man sich da mal zusammensetzen.

An Emax Johannes.

Ich habe doch Peitscham, bin doch

Peitscham-Unterstützer.

Ja, aber hast du da den Co-Pilot zum Beispiel an

oder so, weil das ist auch schon ganz okay.

Also ich finde ehrlich gesagt, das ist nicht so gut, wie wenn man jetzt quasi direkt mit...

Wann hast du das letzte Mal probiert, Jochen?

Keins dieser Systeme hat mich je überzeugt.

Okay.

Ich habe es ein paar Mal probiert und das war jedes Mal so...

Johannes hätte es besser gewusst.

Vielleicht ist das das Problem.

Vielleicht weiß ich es einfach besser.

Ja, ich würde es auch sagen.

Na gut, kann man.

Da würde ich aber sagen, dass das genau das...

Wenn der Jochen sagt, dass das bei ihm hilft, dann kann es bei mir nicht sein, dass ich es besser weiß.

Das wäre sehr überraschend.

Wundervolle Überleitung jetzt übrigens, weil Tim Peters,

der Cowork-Entwickler

und Autor von Zen of Python, das ihr bestimmt alle kennt,

import ist,

dann meinte er, der Plan wäre, wenn jemand

ein Feature entwickelt, das du nicht verstehst, dann

knall ihn einfach ab. Und das ist der

Einstieg in das wunderschöne Buch

von Tim Peters. Ja, muss man direkt mal klar machen,

wie die Sachen dann so laufen und genau Das ist auf jeden Fall einfacher halt etwas Neues zu lernen Ja und dann am Schluss hat man nur noch Leute die irgendwie kein Problem mehr haben das zu verstehen was man sagt Ja und bevor die einzelnen lebenden Entwickler dann

kann man ein kleines Stück

von dem, was man schon tun kann, dann verwenden

und kommt damit weiter.

Also sind wir jetzt

bei Flutpaten?

Ja, ich würde tatsächlich jetzt

so ein bisschen unser Quatsch

versuchen, in eine Struktur zu überführen,

die uns ein bisschen zurückführt auf dieses

wundervoll.

Fluent, was heißt denn Fluent?

Flüssig? Also ich wollte nicht über das Buch sprechen.

Fließend.

Eigentlich wollte ich gar nicht erwähnen,

dass sie das Buch klauen.

Ach so, du wolltest einfach so tun,

als ob das deine...

Entschuldigung.

Den Spaß verdauern.

Okay.

Ja, wir können das auch sagen, das ist ja kein Problem.

Aber genau, was wir...

Was es heute

im Grunde geht, ist halt, wie

nennen das Python Data Model oder

im Buch wird es auch so genannt, es wird auch in der Referenzdokumentation

so genannt. Es gibt andere Leute, die nennen das irgendwie

anders, Python Object Model oder so.

Und im Grunde geht es darum,

was ist denn das jetzt überhaupt wieder alles?

Also ich tue jetzt mal einmal so.

Tu mal so, als ob du das nicht wüsstest.

Ja, genau, das sage ich doch.

Wie immer.

Also zum Beispiel

ist halt

ein super Beispiel ist halt,

um da vielleicht einen Einstieg zu finden,

sagt man in Python eigentlich irgendwie

len von irgendwas, irgendeiner Collection

oder so und nicht

Collection.len, Klammer auf Klammer zu,

wie man das jetzt vielleicht in Ruby machen würde oder so.

Ich weiß ehrlich gesagt gar nicht, wie man es in Ruby macht, aber

In Java, sehr geile Frage.

Die machen das komisch.

Genau, warum macht man das eigentlich so?

ja, also der, das was

halt

Python an der Stelle halt anders macht,

ist halt, dass es irgendwie ein bisschen

objektorientierte Purity sozusagen

irgendwie opfert, um halt

eine Menge andere Vorteile zu kriegen.

Und ja, das macht es, also

das ist überhaupt so eine charakteristische Geschichte von

Python, dass man halt

oft irgendwie, ja halt

nicht die reine Lehre irgendwie macht,

sondern halt irgendwie etwas, was nicht ganz so rein ist,

aber was halt praktisch viel besser funktioniert.

Ich verstehe jetzt meine Sache nicht. Also warum ist erstens irgendwas mit

Klasse und Attribut und Methode

called die reine Lehre und zweitens, was ist

das Problem, wenn man irgendeine Funktion hat oder eine

Call it whatever you like

oder Closure und kippst da

ein Objekt rein und dann

passieren Dinge damit.

Also sozusagen, wenn du jetzt reine Objektorientierung

machen wollen würdest, dann würde man ja

sagen, naja gut, du schickst halt irgendwie Nachrichten

an ein Objekt oder du rufst halt Methoden auf oder was auch

mal, wie man das nennt. Und

das ist dann die Sache des Objekts.

Warum?

Das ist zum Beispiel in Java so.

Ja, aber warum ist das so?

Java heißt Kingdom of Nouns

und es gibt quasi keine

Funktionen in Java, sondern es gibt nur Objekte

und denen kannst du Nachrichten schicken und die

machen dann irgendwas. Und das ist der einzige

Mechanismus, den es im Wesentlichen gibt.

Und selbst wenn du sowas hast wie eine Main-Funktion,

dann hast du da irgendwo eine Klasse und dann ist

es halt eine Static-Methode

auf dieser Klasse drauf.

Und anstatt, dass du sagst,

wenn unser Programm läuft, dann rufen wir die

Main-Funktion auf, sagst du, wir schicken

eine Main-Nachricht an unsere

Main-Klasse. Aber warum

würde man auf die Idee kommen, dass das

eine gute Idee sein könnte?

Naja.

Also was ist das, ich muss mal kurz über die Trade-Offs reden,

um das mal so zu retten. Warum wollte man

denken, dass das eine gute Idee sein könnte,

sowas zu tun?

Naja, es reduziert natürlich schon die Anzahl

von Dingen, die es so gibt.

Es hat nur Objekte und Methodenaufrufe und mehr nicht.

Und das ist warum gut?

Also Simplicity.

Einfach eine Sache lernen.

Auch haben es Razer, weil Einfachheit ein Wegweiser

zur Wahrheit ist oder zur Schönheit oder so.

Okay.

Point 1 für den Java-Entwickler.

Ich bin dir.

Ja.

Okay, und Alvar, warum ist es denn nicht auch einfach,

einfach sowas wie funktionale Programmierung zu machen

und da Zeug hintereinander hin und her zu reichen?

Was fehlt einem denn da in diesem Vergleich?

Funktionale Programmierung ist auch was anderes.

Das gibt es auch, aber das ist was ganz anderes.

Also das ist ja ...

Also kann man auch machen.

Aber dann ...

Kannst du auch Pure haben, sowas wie Haskell oder so.

Oder Erlang oder weiß ich nicht.

Ah, Standard-ML.

Ja.

Das ist halt ein anderes Konzept als jetzt Objektorientierung.

Naja, aber wir sprechen gerade von ästhetischer Einfachheit oder so.

Jaja, ist es auch, aber es ist halt anders.

Da gibt es halt nur Funktionen sozusagen.

Okay, aber ich wollte kurz auf die Trade-offs hinaus, weil, warum ist das jetzt?

Naja, also der Grund, warum man jetzt denken könnte, dass es halt im Python nicht so schön ist,

halt, dass man sagt, das muss man halt auch noch

so, jetzt haben wir so Build-Ins wie Lenn oder so,

die so ein bisschen komisch sind,

aber tats hat es halt praktisch sehr viele Vorteile wie naja also einmal du musst dir nicht f jedes Objekt merken wie das denn jetzt nun hei mit dieser Methode

weil das kann ja jeder dann anders machen, das wäre ja

irgendwie schlecht.

Das ist zum Beispiel ein Problem, was PHP hat

oder JavaScript, da heißt es

manchmal Size und manchmal Length und manchmal

Count.

Und eine andere Geschichte ist

halt, es ermöglicht dir halt

irgendwie

so ein paar dreckige Optimierungen zu machen,

die halt irgendwie die Dinge,

die wirklich Zeit kosten, irgendwie

deutlich schneller zu machen. Wie zum Beispiel

du kannst halt da diese

Sachen, so tatsächlich was Len halt

macht, ist ja schon dann

quasi, wenn das ein Objekt ist

einer Klasse, die du erstellt hast, dann wird

halt dann da Len

aufgerufen. Schon doch die Methode, die geheime

Methode aufgerufen.

Aber die ist halt nicht dafür da,

dass irgendwie andere die aufrufen,

oder dass man die von Hand aufruft

zu Fuß oder wie auch immer,

sondern die ist halt dafür da,

dass der Interpreter die aufruft,

wenn man halt len von irgendwas sagt.

Und dann ruft der Interpreter die auf,

aber der Interpreter kann halt auch andere Dinge tun.

Der kann zum Beispiel jetzt,

wenn das irgendwie so ein native,

also ein Ding im Interpreter selber ist,

also irgendwie ein C geschriebenes Ding

wie ein Dikt oder eine Liste oder sowas ist,

dann kann es halt direkt irgendwie

in diesem PyObject irgendwie drauf gucken,

wie lang ist denn dieses Ding

und gibt es dann halt zurück.

und muss halt keine Methode aufrufen.

Also Methodenaufrufe sind halt etwas, was halt in Python

super langsam ist. Oder in allen

interpretierten Programmiersprachen,

die so ähnlich sind wie Python, sind halt Funktionsaufrufe,

Methodenaufrufe immer total langsam.

Da ist wirklich so ein Faktor 1000

dazwischen, zwischen reinem C

und Funktionsaufruf

und Python oder so.

Und ja,

für die ganzen Standardfälle, wo

man das halt benutzt, kann der

Interpreter das halt alles wegoptimieren und dann

macht er das halt einfach nicht, sondern da wird gar nichts

aufgerufen.

Also das sind halt zwei große Vorteile,

die man halt kriegt, wenn man halt ein bisschen

Reinheit opfert, sozusagen.

Und genau, das ist halt

irgendwie diese Balance zwischen

Reinheit

und funktioniert super.

Und Magie.

Genau, ist halt so eine Spezial...

Magie mag jetzt zum Beispiel der Autor von

Flo und Python an der Stelle gar nicht so

gerne.

Man nennt die Dinger ja irgendwie

Magic Methods auch, also dieser

Magic Methods.

Das finde ich eine sehr schöne Diskussion

über diese Namen, über die Magic

Methods und über die nicht Magic Methods.

Ja, fand ich auch so.

Das kommt halt so aus der Ruby Community,

das wusste ich gar nicht. Ich dachte eigentlich,

es gibt halt ein paar Python-Entwickler, die nennen das halt

Magic Methods, die dann sagen halt Dunder Methods

oder sowas.

Ja, aber in der

Ruby-Welt ist das wohl üblich.

Und ja, aber der...

Das ist der offizielle Name, oder, an Ruby?

Ja, ja.

Die heißen Magic Methods.

Genau.

Ja, oder auch in IPython oder so heißen die auch irgendwie Magic.

Und dann gibt es diverse ...

Aber das ist ja auch wirklich Magic.

Das ist wirklich Magic, okay.

Aber eigentlich sind halt eben die Python-Dinger gar nicht Magic,

sondern das ist halt eigentlich völlig klar,

das dokumentiert, was das ist und was das tut.

Und insofern, der Autor sagt selber, er findet das nicht gut.

Die sollten lieber Muggel-Methoden heißen,

weil sie halt so unmagisch sind.

Aber ja.

Ja, er nennt es ja dann auch auf Special Methods einfach.

Special Methods, das ist auch ein guter Name.

Ich glaube, das, was da magisch ist,

ist, dass man die implementiert

und dann werden sie irgendwo her aufgerufen.

Und wenn ihr das nicht weißt,

dann ist das schon magisch.

Ja, ich glaube auch.

Da gibt es Lenden von irgendwas ein

und es wird aber was ganz anderes.

Dass du für Anfänger,

es ist nicht ersichtlich,

dass wenn du irgendwie so eine Methode dazufügst,

die Dinge macht, wo du nicht weißt, warum.

Weil das unter der Haube passiert.

Natürlich.

Aber das Spatial war ja auch nicht.

Also magisch schon gut.

Das macht ja Magie.

Ah, es passiert irgendwas,

dann machst du einen String auf irgendein Objekt und dann kommt da irgendwas raus,

weil du eine Rappermethode beschriebst.

Ah, Magie.

Ja, wobei das natürlich

eine sehr dünne Schicht Magie ist.

Wie der Jochen schon gesagt hat,

da gibt es eine Liste, so viel Magie

gibt es und die sieht auch so und so aus

und im Wesentlichen ist das ja nur eine

syntaktische Umformung.

Damit syntaktische

Magie, genau.

Ja, aber das ist dann quasi echte Magie.

Echte Magie, da fummelt jemand vor den Augen

mit deinem Finger an Schnipsen rum

und auf einmal zieht er hinter seinem Ohr

eine große, goldenen, glänzende Münze.

Ja, das sind Illusions, das ist keine Magie.

Das ist so ein bisschen, aber so eine taktische Magie.

Ja, aber echte Magie ist doch das,

was man aus Harry Potter kennt.

Dann schwingst du da in den Zauberstab und dann passiert irgendwas.

Die richtigen Worte in der richtigen Reihenfolge sagen.

Genau, das ist so.

Das macht irgendwas, was thermodynamisch nicht möglich ist.

Ja, genau, da sind wir uns eigentlich alle relativ einig.

Das gibt es halt auch nur in Harry Potter oder in...

Ich weiß nicht, also ich finde tatsächlich...

Und in Ruby.

Die Analogie auch gar nicht so schlecht f Programmierer insgesamt Also ich meine man sagt irgendwie die richtigen W in der richtigen Einfolge und dann passieren Dinge Ich finde das ist gar nicht so weit hergeholt dass man das vergleicht Deshalb sind wir alle Wizards Ich habe auch so einen Wizard Es gibt auch tats Leute die Nicht als Muggel bezeichnen Also ich wei so weit w ich jetzt nicht gehen vielleicht

Echt, ich bezeichne die mal als NPCs.

Ja.

Tatsächlich, das erste

Beispiel in einem

nicht näher benannten Buch, was ich kürzlich gelesen habe,

das hat

mich tatsächlich etwas überrascht. Da war tatsächlich

ein bisschen Magie drin. Und zwar

da wird ein CardDeck

implementiert

und er implementiert nur zwei von diesen

Methoden, ja für

Kartentricks dann

und er implementiert nur zwei Methoden, nämlich

dann der Len und dann der GetItem

und das reicht

aus für Slicing und Ranges

und Iteration, das hat

mich etwas überrascht, dass der

Python-Interpreter sich aus einem GetItem

aus dem Len, kann er sich alles zusammenbasteln

ich meine es ist nicht, wenn man so ein bisschen

drüber nachdenkt, ist es einfach nur smart,

dass das geht und

das ist auch klar, dass das geht. Wenn ich weiß,

wie viele es sind und ich ein einzelnes holen kann,

dann kann ich auch mehrere

holen. Okay, gut.

Und ich kann auch

Reverse machen drauf. Okay, auch das ist nicht

arg überraschend. Und ich kann auch

Iteration machen drauf. Okay, auch das ist nicht arg

überraschend mehr. Aber

dass das implementiert ist, das fand ich

sehr cool. Ja, man delegiert

im Grunde die ganze

schlaue oder die ganze schwierige Funktionalität

von, wie das halt so

funktioniert, an die interne Liste in der Datenlage.

Genau, wie das schnell auch funktionieren kann, indem man einfach so eine

Längen-Get-Item definiert.

Nee, Jochen ist nicht delegiert.

Sondern der ruft

Längen-Get-Item an. Ja, aber das macht ja die interne

Repräsentation von Längen, wird ja aufgerufen.

Also das heißt, die Magie, die wirklich

dann in C-Python passiert, die ja damit

schnell ist und so.

Gut, in dem Beispiel wird

nicht implementiert,

wie du tatsächlich Objekte speicherst, sondern

benutzt eine Liste. Genau, es wird halt

sozusagen, das wird weitergereicht, die Position wird

weitergereicht an die Liste. Genau.

Und die kann halt auch slice.

Die Implementierung dieser

beiden Attribute ist

tatsächlich, also ist einfach

durchdelegiert. Aber dass du dann daraus

eine slicing Syntax

kriegst mit ranges, das ist

ja, das macht ja der Interpreter für dich.

Ja. Also der macht

sich diese ranges und ruft dann die einzelnen

get-items auf. Ja.

Also hat mich auch gewundert, hätte

hätte jetzt auch nicht gedacht, dass man

dann schon iterieren kann.

Genau, das war mir gar nicht

klar, dass das reicht, GetItem zu implementieren.

Also ich muss meine naive Karteninterpretation

von meinem Kartenspiel, von meinem Pokerspiel

auch nochmal anpassen, wenn ich das so sehe, weil

tatsächlich ich da auch immer dann ein Objekt

gemacht habe, an dem Karten dran waren, was natürlich dann eine Liste war,

was aber nicht hieß, dass man

einfach das Ding mischt, sondern

muss halt diese Mischmethode aufrufen. Ich glaube, das ist einfach totaler Quatsch.

Ja,

da gibt es aber auch verschiedene Ansätze, da kannst

auch auf verschiedene Arten und Weisen drangehen.

Du kannst drangehen und sagen, ich mache jetzt

eine neue Klasse,

die eine Liste einpackt

und dann halt so ein paar magische Methoden,

ich sage jetzt ja magische Methoden, exportiert.

Oder du kannst sagen,

ich behandle jetzt eine Liste wie ein

XYZ und

dann implementierst du erst mal

selber gar nichts, sondern

benutzt halt die Werkzeuge, die es gibt

auf eine bestimmte Art und Weise. Das sind ja schon

zwei unterschiedliche, aber gleich lästige

Herangehensweisen. Aber dieser letzte Ansatz, das ist irgendwie

wirkt also smart.

Weil man halt tatsächlich nicht das Rad

neu machen muss.

Der ist ein bisschen impliziter, ja.

Aber trotzdem sehr personisch, sehr sens-implizit.

Und in der Kombination,

indem man das halt irgendwie schön

modularisiert, kann man tolle Sachen machen.

Also man muss da so ein bisschen Boilerplate

schreiben vielleicht, aber wie man es dann hinterher

wirklich benutzt, wenn man diese Objekte in der Hand hat,

wirkt einfach wie pure Python.

Wenn man halt dann direkt auf diesem Deck,

was man in der Hand hat, Indizes

machen kann, Vendors machen kann und so.

Ja gut, hier geht es ja vor allen Dingen

darum, diese Methoden zu erklären. Insofern

überhaupt, ob man das jetzt so implementieren würde, weiß ich nicht.

Also keine Ahnung. Kommt drauf an, was man damit machen

möchte, aber ja.

Ja, ja, also ich finde es auch,

also es sieht gut aus. Kann jetzt keiner

sehen, weil es ein Podcast leider.

Aber ja, ja.

Kannst du das teilen? Ist das public?

Nee.

Oh.

Na gut, also ich glaube, es gibt

irgendwo bestimmt auf irgendwelchen

YouTube-Kanälen oder sowas. Ja.

Das nächste

Beispiel, was er bringt, fand ich auch interessant,

aber das ist natürlich so ein bisschen

dieses Vektorbeispiel, das ist natürlich

mehr so ein bisschen,

ja.

Du musst das einfach weiterleuchten, bitte, für alle unsere Hörer,

was denn das Vektorbeispiel ist.

Ja, er macht sich eine Klasse,

eine zweidimensionale

Vektorklasse.

Also mit Richtung XY.

Genau, also ein Koordinatmodell,

ein zweidimensionales Koordinatmodell.

er sagt auch gleich im Vorhinein,

könntest du auch die

Bild-In-Klasse Komplex verwenden.

Die kann alles, was wir gleich

hier machen und noch viel mehr.

Aber zum Zeigen ist es ja ganz schön.

Und da implementiert

Hier hat er drei Special Methods, nämlich Add, Abs und Mool.

Und kriegt daraus dann die Möglichkeit, zwei Vektoren zu addieren.

Abs wird hier als die Metrik implementiert, das heißt, es ist die Länge eines Vektors.

Und Mool ist eine Skalarmultiplikation, das heißt, du kannst deinen Vektor mit einem Integer oder mit einem Float multiplizieren, kannst du die Länge verändern.

Auch das mit wenigen Methoden

schon relativ viel erreicht

und auch relativ viel Syntax erreicht.

Das fehlt aber noch Vektor mit Vektor multiplizieren.

Ja, das ist nicht so

einfach, das ist nicht so einfach dummerweise, weil

Das ist mathematisch nicht so einfach.

Genau, da steht

glaube ich im Buch irgendwas drin, ja, also wie man

das dann macht mit Magic Method, das ist dann

Kapitel 16 oder so viel weiter hinten,

weil das ist nicht so einfach.

Und er sagt auch, er verschiebt

auch, das tatsächlich in diesen ersten Kapiteln

verschiebt er relativ viel auf später.

Ja, hier, das kommt in Kapitel 17 nochmal.

Oder in Kapitel 38 oder Kapitel 12.

Tatsächlich auch

Skalar mit

Vektor multiplizieren, also

eine Zahl mal Vektor

verschiebt er auch auf später, weil da brauchst du

nochmal eine andere Special Method,

weil eben Mull nur

Vektor mit Skalar kann.

Und das ist dann so ein kleines bisschen

unbefriedigend. Was ich aber eigentlich,

worauf ich eigentlich raus wollte, ist,

er hat halt dann die Möglichkeit,

seine Klasse mit Plus, hat er zwei Vektoren,

zwei Instanzen von seiner Klasse, kann er mit

Plus addieren. Und

das fand ich nicht so beeindruckend,

weil

das gab es in C++ auch schon.

Das musste ich auch schon mal lernen.

Und da heißen die Methoden halt anders,

da heißen sie Operator Plus und Operator Minus

und Operator noch irgendwas. Und dann

kriegst du es aber auch. Da kannst du auch

Vektoren addieren und so weiter.

Deshalb, da war ich jetzt

nicht so beeindruckt davon.

Ja.

Ich habe das mit dem Multiplizieren nicht verstanden,

was du meinst mit Skalar mal Vektor und Vektor mal Skalar.

Wo ist der Unterschied? Ist das nicht kommutativ?

Das ist die Reihenfolge.

Eigentlich mathematisch gesehen

ist diese Operation kommutativ,

aber in Python an dieser Stelle ist sie noch nicht

kommutativ, weil wenn du

die Mull-Methode

implementierst

auf deiner Klasse,

dann musst,

wenn du x mal y machst,

dann wird x.mull

aufgerufen. Weil ansonsten wird dann tatsächlich

ja, genau, sonst von dem

Skalar die MUL-Methode aufgerufen, da gibt es

den Vektor nicht. Genau, und die kann natürlich nicht mit Vektoren

umgehen. Und damit es in die andere Richtung geht, brauchst

du eine zweite Special Method, da heißt

RMUL, also Reverse Multiplication.

Und die hat aber auch später verschoben, weil

die später nochmal kommt.

Ach, man kann auch RMUL? Interessant.

Das wusste ich auch nicht. Genau, damit du eben

diese Kommutativität.

Aber es wird zuerst MUL aufgerufen.

Das heißt, da geht es dann

auch noch um Präzedenz und deshalb verschiebt

du das, glaube ich, auch später.

Wie kriegt man denn die Präzedenz hin?

Also ich möchte das gerne spoilern.

Die kriegst du

hin, also ist in dem Fall jetzt

hier tatsächlich unproblematisch, aber du musst dann natürlich

Typechecks machen, dass du sagst, okay, was ist denn,

wenn ich ein R-Model mache mit

dieser oder jener Sorte von

Objekt, weil da kann ja dann prinzipiell alles

rein.

Matchcase.

Ja, so

mit einem Matchcase oder mit einem

Was du nicht implementiert hast,

wird einfach im Normalkreis abgehandelt und ansonsten

schreibst du für alle Kettes, die

einmal auftauchen, was

rein. Finde ich gut.

Ja, im Endeffekt macht der Interpreter

das ja auch so. Also wenn eine von

diesen Methoden halt einen Fehler wirft

oder keine Ergebnisse zurückgibt, dann

wird halt so lange weitere Methoden

durchprobiert, bis es eins gibt und wenn es

keinen gibt, dann sagt der Herr, das ist nicht definiert für

diese Typen.

Das haben wir ja auch alle schon mal gesehen, oder?

Dass man versätlich einen String zu einer Zahl

addiert hat und dann gesagt bekommen hat, das

Kannst du nicht. Es sei denn, man war in JavaScript.

Ja, ja, das ist halt

so ein fundamentaler

Unterschied zwischen JavaScript und

Python.

Ja, aber, ja, ja.

Ja, also ich, genau, ich finde das

ja auch sehr, ich finde, ich weiß nicht, haben wir überhaupt

schon definiert, mir fällt das gerade so heiß ein, jetzt reden wir

schon die ganze Zeit drüber, aber ich weiß nicht, haben wir überhaupt gesagt, was,

wie diese

Dunder-Methods denn aussehen?

Also die sind immer, haben

immer irgendwie zwei Underscores,

damit fangen sie mal an und hören immer mit zwei Underscores auf.

Genau, Dundar, für alle, die es nicht kennen,

ist Unterstrich, Unterstrich.

Dundar ist halt quasi die Abkürzung für

Double Underscore Before

und Double Underscore After.

Warum machen Underscores damit? Man denkt, die gibt es gar nicht,

damit man die nicht sieht, damit die nicht auffallen.

Nö, Konvention.

Keine Ahnung.

Wie du sie unterscheiden kannst von allen anderen.

Das ist eine Konvention im Python-Interpreter,

wenn du eine Methode hast, die zwei Unterstriche vorne

und zwei Unterstriche hinten hat,

dann verspricht der Interpreter gar nichts darüber.

Das kann sich jederzeit ändern und es kann jederzeit passieren,

dass die nicht mehr funktioniert.

Es ist einfach nur eine visuelle Abtrennung dass du siehst dass das was Spezielles ist Aber wenn ich das richtig verstehe ruft man solche Methoden niemals selber einfach so an Niemals stimmt nicht so ganz also ab und zu schon

Also eine ganz populäre ist, achso, das wolltest du auch gerade

sagen, ist halt

dann der Inet.

Ja.

Wann ruft man denn Inet explizit auf? Von außen?

Ständig. Nur mit Super?

Ständig. Nee, ständig.

Wenn du halt Klasse, Klammer auf, Klammer zu,

dann hast du schon aufgerufen.

Nein, aber das ist ja implizit.

Ja, aber das ist ja die implizite.

Ich meine, dass du explizit jetzt dran schreibst init.

Ja, okay, das passiert tatsächlich nicht so häufig, ja.

Ja, bei super aufrufen schon.

Ja gut, aber nur super,

das ist ja absolut im anderen init.

Und das offensichtlich.

Aber außer dem Fall kenne ich jetzt eigentlich keinen.

Also es sei denn, man will irgendwas debuggen oder sowas,

dann machen wir alles anders, aber ja.

Es ist halt auch nicht notwendig.

Das ist ja der Trick da dran.

Ja, aber deswegen braucht man jetzt eine App,

definiere, dann mache ich einfach einen String, dann kriege ich das Ergebnis.

Und wenn ich einen Abs definiere, dann möchte ich halt irgendwie

mit Dingen rechnen

und gucken, was passiert. Oder beim Bool

vergleiche ich mit irgendwas oder so. Oder ich mache ein If vor.

Aber ich würde dir niemals selber das

vormachen. Und das ist ja vielleicht das Interessante an den

Thunder-Messages, dass sie halt quasi die

Reimplementierung sind, um

mit normaler Python-Syntax und den

Objekten zu interagieren. Also zum Beispiel Equals

oder so oder Lesser-Send oder

ein komparatives Verhalten zwischen einzelnen

Objekten von Klassen

oder von Instanzen.

Ja, du kannst halt sozusagen mit dem Interpreter

so interagieren, wie die anderen

Teile in Python halt auch

und das ist halt eine Besonderheit von Python, das geht in vielen

anderen Sprachen nicht. Genau, das macht es halt toll

und das ist halt schön, das ist halt genau

das Schöne an diesen Magic

Methods ist, dass wenn man das ordentlich implementiert

man hinterher in seinem Code

Sachen machen kann, die sehr natürlich

aussehen und die auch in der

logischen Sprache dann natürlich Sinn

machen, wenn man Dinge miteinander vergleichen möchte

die man dann vielleicht auch vergleichen kann, weil man denen

ordentliche Namen gegeben hat und das aber einfach mit den

instanzierten Objekten geht und man halt nicht

irgendwie komische Dandan-Methoden oder

irgendwelche kryptischen Namen

an Objekten aufrufen muss,

wie das in anderen Sprachen der Fall ist. Und das ist toll,

weil dieser Syntax-Sugar Magie macht

und deswegen finde ich den Namen Mindigmas

jetzt auch sehr schön.

Ja, du kriegst also Zugriff auf die

Innereien

des Parsnip-Debretas und

du kannst dich da genauso rein integrieren,

als ob du dazugehörst

und das ist schon was sehr Schönes.

Aber du hast eben noch was anderes gesagt, Dominik,

was auch hier vorkommt, was ich auch in meinen Notizen

habe. Du hast gesagt, du möchtest hier

die Strill-Methode implementieren und dann kriegst du eine

schöne String-Repräsentation raus.

Ich habe die Repr-Methode gesagt.

Oh, dann muss ich noch mal

zurückscrollen und mir das anhören.

Aber das ist tatsächlich was, ich tendiere

auch dazu, immer die Strill-Methode zu implementieren,

weil man

das halt so gewöhnt ist. Bei Java machst

du Two-String, bei irgendwelchen

anderen machst du irgendeine Two-String-

Transformation oder was auch immer.

und in Python gibt es ja zwei davon.

Es gibt Repre und Stre.

Genau.

Und der Unterschied ist

schwer zu erklären,

weil

der ist nicht so was

formales. Ich versuche es trotzdem mal.

Die Repräsentation ist das, was in der Kommandozeile

auftaucht oder einem String, wenn du ihn

reingeschrieben hast und Stre ist das, was

rauskommt, wenn du die String

Conversion versuchst.

Ja, aber

Ja, aber warum macht man dann da überhaupt einen Unterschied?

Könntest du da genau mit einer machen dann?

Das eine identifiziert das Objekt.

Okay, erklär du, Johannes.

Das andere auch.

Nee, also das geht schon so ein bisschen runter

auf die Krux des Problems,

weil diese zwei Methoden doch relativ ähnlich sind.

Aber interessanterweise,

wenn du das DIR nicht implementiert hast,

fällt der zurück auf REPR, also auf die Representation.

Und die Representation ist in dem Sinne ein bisschen formaler,

weil das heißt, du sollst eine Repräsentation wählen,

die du idealerweise direkt in den Interpreter rein kopieren kannst.

Und das schränkt dich natürlich relativ ein.

Das heißt, da hast du üblicherweise dann sowas wie

eben einen Konstruktor da drin stehen.

Oder eine String-Repräsentation des Konstruktors.

Die Stereo-Methode soll einfach nur eine menschenlesbare

Beschreibung dieses Objektes sein.

Und die kann dann natürlich auch was anderes sein.

Also zum Beispiel für diese Vektorklasse,

da hat er als Representation halt

den Namen der Klasse, Vektor 2, Klammer auf,

dann die beiden

Koordinaten und dann Klammer zu.

Und das ist gut,

weil das kannst du direkt reinkopieren,

das identifiziert genau diese Sache.

Als Strill-Methode,

hat er jetzt hier kein Beispiel im Buch drin,

würde ich aber tatsächlich

was anderes wählen. Ich würde entweder

je nach Kontext

vielleicht eckige Klammern wählen

oder in einem mathematischen

Kontext vielleicht sogar runde Klammern.

Genaue Spitze-Klammern, Entschuldigung.

Oder vielleicht sogar runde, je nachdem,

welchen Kontext es hat. Und da hat man natürlich einfach

mehr Freiheit, weil das einfach eine

menschenlesbare

Darstellung dieses Objektes sein soll Und ich tendiere eher dazu die Strill zu implementieren und die Argumente

die hier der

Luciano uns gibt,

die

lassen mich jetzt doch auch tendieren, dazu

eher Rappern zu...

Also das ist sozusagen die Regel, die man da mitnehmen

kann, ist halt, wenn man

sozusagen sich entscheiden

muss, dann lieber eher nur die Rappermethode

implementieren, nicht unbedingt Strill.

ja, und das war mir auch

nicht so in der Feinheit

klar, was jetzt da der genaue Unterschied

oder Sinn dahinter ist und das weiß ich jetzt

voll gut, weiß ich schon wieder mehr.

Ja, das war gut, oder?

Ja.

Ja, ja, ja.

Ich war etwas überrascht, als ich das

Buch angefangen habe, weil das erste Kapitel schon

ordentlich rangeht.

Ein Fingerbuch, hat Jochen gesagt.

Nein,

das ist auf jeden Fall ein fortgeschrittenes Buch

und der macht auch keine

Pausen. Der geht direkt weiter

hier. Zwei

Klassen mit Operatoren, also das ist diese

Deck-Klasse und die Vector-Klasse

und dann macht er noch Bool

Implementierung und dann geht es gleich mit der

Collection-API weiter.

Auch das, sehr interessant.

Sehr interessanter

Abschnitt über die Collection-API, wo natürlich jetzt

mehr an Details drin ist, die

ich weder präsent hatte, noch jetzt

so präsent habe.

Ja, also jetzt muss man was trotzdem mal kurz

einmal aufräumen, bitte.

Ja, dafür ist das Buch halt, also das Buch ist schon

dicht, okay, ich gebe es zu, aber dafür ist es halt

auch nicht so lang.

Ja, das stimmt.

Die nächste Lüge.

975 Seiten.

Aber es ist ein Taschenbuchformat,

also kann man locker auch in die Tasche

stecken, ist auch relativ klein.

961.

Also vielleicht 18 mal 20 Zentimeter.

Ja, also das ist auf jeden Fall

doch die Größe, die man sich locker unter das Kopfkissen

legen kann. Damit sich von automatisch

lernt, ja. Du kannst dein Kopfkissen

ersetzen, kannst du das mit dem Buch.

Ja.

Ja, aber

tatsächlich, also diese,

da ist sogar ein UML-Diagramm.

Das muss ich sagen, weil ich so fast ein bisschen

abgeschreckt bin. Oh, jetzt kaufe ich es auch.

UML-Diagramm, oh Gott, oh Gott, oh Gott.

Aber ja, an der Stelle macht es tatsächlich Sinn.

Ja.

Dominik und ich,

wir blättern jetzt gerade für die Zuhörer.

Ja.

Genau, da gibt es halt

einen UML-Digramm von der Collection

API.

Was ist jetzt die Collection API? Ich habe es immer noch nicht genau verstanden.

Bitte wiederhol das doch nochmal.

Ja, also die ist

Was ist überhaupt eine Collection?

Worum geht es da?

Meta-Tools?

Da geht es darum, wie

grundsätzlich quasi

Objekte in

Python irgendwie so

funktionieren, die eine Collection von irgendwas sind.

und das sind halt die allermeisten.

Das sieht jetzt hier nicht so aus, das sieht nach irgendwas Speziellem aus,

aber das sind halt die allermeisten,

sowas.

Und da gibt es, also Collection

selber,

damit es eine ist,

also

damit es eine ist,

quasi müssen drei Sachen

irgendwie

implementiert sein. Also es gibt halt drei Methoden,

die sozusagen

dann ein Ding zu einer Collection machen

und das ist halt...

Iter? Iter, ja. Du kannst halt

irgendwie drüber iterieren.

Also einen Iterator bauen, einen Generator,

der irgendwas yieldet.

Nein.

Es muss halt irgendwie...

Fast. Mal ganz generell,

so eine Collection ist einfach

eine Sammlung von anderen Sachen.

Eine Sammlung von anderen Dingen.

Und um das zu ermöglichen,

gibt es jetzt hier diese verschiedenen Interfaces, die der Jochen

jetzt gerade...

Es muss ein Iterable sein, ja, und dann?

Es muss nicht, aber kann.

Doch, muss eigentlich.

muss, damit man irgendwie eine Collection ist.

Also ist this a part of your collection?

Wie viel bist du denn?

Und gib mal mehr von dir.

Von allem, was in dir drin ist.

Wenn ich über alles iteriere,

dann habe ich alles drin, was drin war.

Alles Toys.

For everything in collection.

Ist das so?

Muss ein Iterator über alle

drüber gehen?

Ich denke nicht.

Wenn du das implementierst,

dann kannst du da drin ja machen, was du willst.

Das kann jetzt auch von irgendwas anderem

abhängig sein, was das...

Du musst nur das ITER-Protokoll erfüllen.

Ja, genau.

Du musst nur das Protokoll erfüllen.

Ein nächstes rausgeben.

Ja, ja.

Also immer dasselbe.

Diese pathologischen Edge Gib mir mal alle deine Dinge Ich will das erste Nee du kriegst das erste Du kriegst doch das erste Nein darfst immer das Erste Immer das Erste Nee nee du rufst ja das Iterable ist ja du rufst immer Next auf dem Iterable Ach das ist doch ein kleiner Wartegang

Das heißt, du kriegst immer ein nächstes Element.

Aber das bedeutet nicht, dass du alle kriegst.

Und das bedeutet auch nicht, dass du alle kriegen kannst.

Es gibt ja diese pathologischen Edge-Cases,

die man immer in Einführungsveranstaltungen macht,

dass man sagt, hier, wir machen jetzt mal was Iterable.

Und das berechnet einfach die nächste Primzahl.

Es gibt ja alle Primzahlen.

Aber das ist natürlich keine Sammlung, die je aufhört.

Was ist denn da unter der Primzahlen-Iterin?

Unterschied, Joachim.

Mit dem Generator und dem

Next und dem Yield und dem...

Naja, also Iter ist halt die

grundsätzliche Geschichte. Das ist halt das,

was du brauchst, wenn du vor irgendwas in irgendwas

sagst. Ja, ein Generator

ist halt nicht so allgemein.

So ein Generator heißt halt dann

sozusagen da

kriegst du halt

eins nach dem anderen dringend.

Also wenn ich jetzt irgendwas iteriere, ist es was anderes

als ein Eins nach dem Anderen?

Also sagen wir mal so,

Generator ist nochmal eine speziellere Geschichte.

Das hat halt irgendwie, das ist jetzt

nicht das Gleiche, wie irgendwie was,

über was du iterieren kannst. Das ist was anderes.

Ein Generator implementiert ja.

Ein Generator implementiert das

Iterable-Protokoll.

Ja, genau. Also ist schon

Iterable ein Generator, aber es ist ja eine sehr spezielle

Art von was Iterable.

Aha.

Aha, okay.

Aber eine Liste ist auch irgendwie was

iterables, aber das ist kein

Generator, gar nicht. Nein? Nein.

Als Comprehension schon? Also wenn du eine List

Comprehension schreibst, kriegst du eine Liste zurück.

Du kannst den Generator-Expression

hinschreiben, dann kriegst du einen Generator, aber das ist wieder was anderes.

Also, ja.

Aber

interessant finde ich halt, dass das halt

reicht. Also diese drei Dinge,

also wenn du halt die, wenn du die

Danner-Methods iter, len und

contains implementierst, dann hast du halt

ein Collection quasi.

Und dann gibt es halt noch die eine

zusätzliche Geschichte, die halt

sozusagen dann daraus

etwas nochmal was Besonderes macht.

Das ist halt Reversible.

Wenn das irgendeine

Reihenfolge hat, dann ist es halt

eine Sequence.

Aber das ist halt das, was das unterscheidet.

Also eine Sequence kann halt irgendwie beliebig sortiert werden.

Das macht es halt besonders.

Und das klassische

Beispiel ist eine Liste.

Wenn man Sequence sagt, kann man immer an Liste denken.

Und genau, ansonsten ist halt ein Dikt,

ist halt auch ein Collection, ist halt ein Mapping sozusagen.

Ein Set ist keine Liste, aber ein Set ist schon eine Collection.

Genau, das ist der dritte Basistyp.

Aber keine Sequence.

Also das sind dann die Basistypen, die sie da ableiten.

Sequence, Mapping und Set.

Und die drei verhalten sich unterschiedlich.

Und daraus, das sind aber die Dinge, die man dann einsetzt.

Also diese Bausteine, also ein pures Iterable, ich meine, geht prinzipiell schon.

Oder ein pures Sized, wüsste ich nicht, dass ich das schon mal gesehen habe.

Aber natürlich Sequence und Mapping und Set, das sind die Sachen, die man dann tatsächlich benutzt.

Weil da hast du dann die Bausteine zusammengesetzt zu dem, was man tatsächlich einfach braucht.

Das, was dann sinnvoll ist.

Und da kann man dann auch Beispiele sagen.

Also ein Beispiel von einem Iterable könnte ich jetzt nicht unbedingt sagen.

Also von einem puren.

Ein Huhn.

Ein Huhn von einer Sequence ist easy.

Ein Huhn ist ein Iterator.

Legt ein Ei, legt noch ein Ei, legt noch ein Ei, legt noch ein Ei.

Ja, das

wüsste ich jetzt nicht, wenn man es in Python

implementiert, aber ja.

Es gibt

auch Hühner in Pythons.

Dann ist halt die Frage, was war zuerst da?

Das Ei oder das Huhn?

Wenn du eine große Schlange hast, kannst du

ja mal einen Huhn reintun und dann schauen, ob es

iteriert. Ich habe letztens irgendwo

so ein Schaubild gesehen, wo ein Biologe meinte

sowas, so eine Quatschfrage.

also wir malen hier einfach mal

so diesen evolutionären Schlamm auf und da haben wir

überall Eier, aber nur da ganz

unten ein Huhn.

Natürlich war das ein zuerst.

Völlig triviale

Frage.

Okay.

Genau und Mapping, ich meine das kennt man auch,

das ist ein Dictionary und Set kennt man auch, das ist ein Set

und das sind dann die Sachen, die man tatsächlich benutzt.

Aber diese Protokolle, also das, was

die tatsächlich an Funktionalität anbieten,

das ist hier zusammengesetzt

aus diesen ABCs, aus den

AbstractBaseClasses.

Benutzt die das eigentlich immer?

Der Trick ist, dass wenn du

diese ABCs implementierst, dann

genau wie vorhin bei den Special Methods

oder bei den Magic Methods, dann kannst

du dich in den Python-Interpreter so rein integrieren, wie

wenn du ein Dict wärst oder eine Liste

oder was auch immer.

Also dann habe ich ein Interface implementiert.

Kann man das so sagen?

Ja, es heißt hier nicht Interface, sondern Protokoll.

Aha, das heißt vom

Typing Protokoll kann ich das dann benutzen?

Das ist nochmal eine andere Geschichte, aber ja, das funktioniert dann, das ist eine andere Art, das zu machen.

Aber das macht quasi, deswegen, also AppStack-Base-Klasse, ja, braucht man das?

Also du kannst, also das Problem bei der AppStack-Base-Klasse, das funktioniert halt anders.

Es ist halt sozusagen, das hatten wir in der Typing-Episode auch, es ist halt sozusagen nominatives, nominative Typisierung sozusagen in dem Sinne, dass du jetzt bei jedem Ding, das du erzeugst,

dass du von so einer Abstract-Base-Class erbst,

sagst du halt genau, was es ist.

Und das ist das, weil

du es davon erbst.

Bei Protokoll nicht, weil es kann nicht das sein.

Deswegen ist Protokoll eigentlich viel flexibler für sowas

und auch viel besser geeignet.

Ja,

aber es hat dann natürlich auch wieder

Nachteile. Naja, wenn du sagst, es muss

eine Collection sein, die da reingeht, dann ist doch scheißegal,

was für eine Collection das ist.

Wenn du das Protokoll der Collection erfüllst

und die dann, des Mappings

oder des Sets oder sowas, und da ist irgendein Set,

das da rein muss, aber du sagst halt, es muss halt diese Sachen

da drin haben, die im

Protokoll definiert sind, also in

den Methoden, die man für ein Set halt braucht.

Genau, aber was sagt der damit?

Ja, aber dann ist das doch okay, aber da muss ich doch keine

Abstract-Base-Klasse verwenden, das ist irgendwie

komisch. Doch, klar.

Das ist ja genau die Formalisierung davon.

Du erbst von dieser Abstract-Base-Klasse,

dann hast du erstmal nichts umgesetzt, dann implementierst

du die ganzen Sachen. Nein, Protokoll.

Dann wirst du zu einer Collection. Deine Klasse

ist eine Collection. Dann kannst du es auch

überprüfen. Wenn du nur im Typing

sagst, das entspricht dem, dann hast du es nicht

überprüft. Wenn du Protokoll-Dings machst, dann würdest

du sagen, ist Collection, also ist Instance

of Collection, sagt dir halt,

nee, eher nicht.

Was du dann machen

kannst, ist halt,

dein statischer Type-Checker kann immer

noch Fehler finden.

Mein Linter sagt mir halt, ja, nee, aber

der will jetzt ein Collection haben und

nichts anderes. Ja, aber wenn da jemand anders

ein ist Instance auf deinem,

was auch immer das Ding ist, irgendwie

aufruft, dann kriegt der nicht und sagt, ist das ein Collection?

dann kommt er zurück, nur ist es nicht.

Ja, okay, weil das kein hartes

Geerbe ist. Weil es ist nicht wirklich eine Collection

in dem Sinne. Ja, man interpretiert nur das Protokoll

als wäre es eine Collection.

Genau, also das ist quasi die

Formalisierung davon. Du gibst

es technisch rein und sagst, das ist eine Collection.

Glaubst du der Sprache,

die das übergibt,

oder glaubst du deinem Linter, der dir sagt,

das könnte passen oder nicht?

Naja, es hat halt alle so Vor- und Nachweise.

Den Linter glaube ich überhaupt gar nicht. Ja, aber warum will ich denn

niemals testen, ob es Instance of Collection ist?

Ich will nur wissen, ob das lintet, weil es die

Methoden implementiert und ich will, ob es

Instance auf, keine Ahnung, meine

Superliste...

Da gibt es ja schon

Use Cases dafür, dass du sagst, okay,

ich will wissen, ist Instance Platten...

Ich habe eine Funktion, die alles Mögliche

verarbeiten kann, muss ja schon eventuell

auf unterschiedliche Arten drücken. Nein, aber ich will wissen,

ist Instance Buch, weil wenn ich nach der

Bücher-Collection gucke und ich will niemals

wissen, ob es eine Collection von

irgendwelchen abstrakten Dingen ist, deswegen ist es

Bullshit, das mit abstrakten Base-Classen. Meiner Meinung nach

dass du noch nie eine Bibliothek implementiert hast,

die so eine Funktionalität anbietet,

ist jetzt schade,

aber so ist es.

Ich meine zum Beispiel,

wo das halt häufig auftritt,

also wo ich das kenne mit den,

dass man halt irgendwie, es gibt halt viele Methoden,

zum Beispiel nehmen wir jetzt bei Data Science Geschichten

irgendwie sowas wie

Data Pipelines oder irgendwelche Modelle oder so

und da

kommen halt manchmal so wirklich

komische Sachen rein und

ich

habe auch schon viel

Scikit-Learn-Code zum Beispiel gelesen und so.

Viele Methoden oder

viele Funktionen, die fangen an mit

also, sag mal, bist du

eigentlich ein sowas? Oder bist du

vielleicht sowas? Und dann machen sie halt unterschiedliche Dinge, je nachdem

was das dann ist. Und

das ist halt teilweise, das ist wirklich lang

am Anfang. Und

ja, ich wüsste jetzt nicht, wie man das

anders machen könnte, außer so. Also

also, ja.

Eine Sorte Funktion, die man auch häufig sieht in Bibliotheken,

ist, wo du entweder einzelne Elemente reingeben kannst

oder gleich eine ganze Sammlung.

Und dann musst du halt auch am Anfang dieser Funktion

in der Implementierung unterscheiden können,

ob du jetzt gerade ein einzelnes Element in der Hand hast

oder ganz viele einzelne Elemente.

Und da musst du schon irgendwie eine formalisierte Unterscheidung machen.

Da hilft dir auch der Linter nix, weil der geht ja zur Laufzeit nicht.

Also es macht schon seinen Sinn, diese Sachen so zu deklarieren,

insbesondere, wenn du eben hier solche,

sage ich mal, grundlegenden Funktionen

implementierst. Man kann

das auch zu weit treiben. Wenn man das zu weit treibt,

dann kriegt man Java.

Ja.

Und man muss

da eine Balance finden.

Ja.

Aber es ist, um

wieder darauf zurückzukommen, es ist schon interessant, dass das

eigentlich so relativ simple Sachen sind.

Also hier dieses UML-Diagramm ist eine

Viertelseite und es stehen

ja wirklich nicht viele Sachen da drin.

Es sind nicht viele Methoden, die man umsetzen muss.

Ja, und das ist halt irgendwie

quasi, also die meisten

oder viele Leute werden sich niemals aus diesem

Universum von dem, was da definiert ist,

rausbewegen, weil damit

quasi fast alles erschlagen ist, was man so normalerweise

so tut. Das ist schon faszinierend, dass das geht, ja.

Ja, außer

Skalare, okay, die stehen da jetzt auch nicht drin.

Ja.

Ja, und dann ist

das erste Kapitel ja schon fast vorbei, dann haben wir noch hier

die der Dunder Da wird einmal nochmal komplett alle aufgef Sch so v ohne Zusammenhang hier mit Metaprogramming und Abstract Base Classes und Attribute

Descriptors und Attribute Management.

Also da

ist es interessant,

da reinzuschauen, was es alles gibt, aber ich wüsste

jetzt nicht bei allen, was die tun.

Was ist der Unterschied zwischen GetAttribute und GetAttribute?

Ja, es kommt

in Kapitel.

Also das eine

ist irgendwie nochmal ein Stückchen

allgemeiner, glaube ich, als das andere.

Ich glaube, Get Utter ist halt das

wirklich ganz allgemeine Ding und Get Out

Reboot ist halt, guckt halt wirklich

ganz tief runter.

Das eine ist näher dran, oder?

Also Get Utter kannst du auch

Methoden überschreiten. Genau, die Frage ist halt,

wann, welches Dick das reinguckt, wenn du guckst.

Aber

so ganz genau weiß ich das jetzt auch alles nicht.

Oder Init Subclass.

Wüsstest du, was Init Subclass macht, Johann? Oder Prepare?

Ich weiß es aus einem

sehr interessanten,

wir haben ja auch schon die Wechsel-Trips.

In der Subclass, das ist halt

der Grund, warum Leute Meta-Klassen

verwenden, ist eigentlich der, dass sie halt

irgendwie die Klasse-Instanzierung ab und zu

mal so ein bisschen modifizieren wollen. Und fast

alle Use-Cases lassen sich, also

Meta-Klassen selber zum Benutzen ist super

viertelig. Man muss extrem aufpassen,

was man da tut.

Und daher

ist das halt so ein bisschen auch in Verruf geraten

und Leute raten einem davon immer, das zu machen.

aber genau,

man kann,

wenn man jetzt

in eine Subclass verwendet, dann kann man fast alle

Anwendungsfälle, für die Leute normalerweise so Metaclassen

verwenden, halt damit hinkriegen

und hat all diese Probleme nicht,

die man halt sonst so kriegt, wenn man Metaclassen verwendet.

Und das ist

eingeführt worden mit Python 3.6

und ich weiß das halt nicht deswegen, weil

ich sowieso immer alles weiß, sondern in dem

speziellen Fall,

in dem speziellen Fall,

weiß ich es, weil...

In diesem Fall weiß ich es, weil

den Pep dafür hat irgendwie...

Wir hatten ja Martin hier auch mal zu Gast, der

irgendwie dann diesen X-File-Rondgen-Laser

geschrieben hat. Und den Pep zur Einführung

von In the Subclass, den hat er geschrieben

und ist damals in Python 3.6 reingekommen.

Ja.

Deswegen hast du natürlich ganz besonders... Okay, dann habe ich jetzt das Falsche gefragt.

Dann sag mal, was Subclass-Check macht

ja auch. Weißt du mal alles? Ja, siehst du.

Weiß ich nicht. Keine Ahnung. Ja, okay, gut.

Also das kommt dann in einem späteren Kapitel

und da sind auch MRO-Entries.

Also ich meine, dass man da sein MRO

bearbeiten kann, das ist ja schon hart.

Kann man sich einfach sagen,

ich bin jetzt trotzdem ein bisschen tiefer

implementiert und ich bin jetzt einfach type.

Ja, keine Ahnung,

ich weiß es nicht.

Wir werden es im Laufe

dieser Vortragsreihe

eine Type vielleicht lernen.

Ja, genau.

Aber was mich auch überrascht hat, ist,

oder machen wir jetzt das ganze Buch heute.

Genau, ja.

das wird jetzt ein bisschen dauern, ihr müsst jetzt

einmal anschneiden,

Türen schließen.

Was ich auch irgendwie

nicht erwartet hätte,

ist, dass halt so viel Zeug

sich um arithmetische Geschichten

und Operator-Overloading

handelt, also mehr als die Hälfte.

Und das wäre mir jetzt auch,

hätte ich jetzt nicht gedacht, wenn man mich jetzt

nachts geweckt hätte und gefragt hätte,

welche Magic-Messages gibt es und was mache ich so,

dann wäre ich jetzt bei sowas wie

Repre oder irgendwie

genau Bool oder weiß ich nicht, sowas gewesen.

Augmented Bitwise Arithmetic.

Ja, aber...

Ja, es ist auch, es geht in beide Richtungen

und dann gibt es mit Integer und dann gibt es mit Reversed

und dann gibt es mit Augmented und dann gibt es mit Bitwise

und mit Reversed und Augmented.

Also das gibt es alles in drei verschiedenen

Varianten jeweils.

Sonst sind es ja nicht so viele, aber

es...

Ja.

Ja, ja, ja.

Ja gut, Mathematik regiert die Welt.

Ja.

das, das, ja.

So ist es.

Ja.

Ja, dann, das ist doch interessant hier.

Und am Ende seines Kapitels hat er immer

noch einen Soapbox

Abschnitt. Eine Seifenkette. Den finde ich auch sehr

schön. Ja, ja, genau, wo er sich hinstellt

und mal ein bisschen predigt. Und das, das fand ich

tatsächlich auch sehr schön.

The Art of the Meta

Object Protocol.

Großartiger Buchtitel und

habe ich mir jetzt auch mal auf meine Liste

Das musst du nochmal genau erklären, bitte.

Ja, ich weiß es auch nicht, ich habe es auch noch nicht gelesen, aber ich fand den Titel gut genug, dass ich es mir direkt auf meine Leseliste gesetzt habe.

Was ich viel interessanter fand noch, war ganz am Ende was, wo er sagt hier, der Autor, der dieses Amob-Buch geschrieben hat,

der hat Aspect-Oriented Programming entwickelt oder getrieben.

Und ich habe es dann mal auf Wikipedia nachgelesen, was Aspect-Oriented Programming ist, aber nicht so richtig verstanden.

Also Aspekt ist auch irgendwas mit Magie, oder?

Da geht es entweder Wasser oder Feuer

oder

Irgendwas mit gegen die Muggel Ja vielleicht ich wei es nicht Ja muss uns mal jemand erkl Ich w gerne mehr wissen wie es geht Aber da sind auf jeden Fall in dieser

Soapbox sind schöne Pointer drin, wo man dann

dem

geneigten Leser als Übungsaufgabe

überlassen werden.

Vielleicht werden die Designer von Go irgendwann das

Meta-Objekt-Protokoll erweitern.

Aber das ist im Moment nicht das, was man

auf dem Niveau

mit dem man in Python arbeiten kann.

Genau, das ist halt das, was wir hier

dann sagt, in anderen Sprachen hast du diese,

hast du die Möglichkeit nicht. In Go gibt es

tatsächlich Magic-Sachen, weil die halt

im Interpreter drin sind, kommst du auch nicht dran, kannst nichts machen.

Und

Pech gehabt. Und das ist

in Python eben nicht so. Deshalb hier

Muggel-Methods. Kannst du,

jeder kann da hingehen und die Finger drauf

legen und dann so tun, als ob er zu Python

gehört.

Du wolltest damit einen exklusiven

Kreis aufmachen, lieber Johannes.

Du musst nur die magischen Worte

wissen und in der richtigen Reihenfolge sagen und

deinen Zauberstab in der richtigen Bewegung schwingen.

Ja, du musst aber schon noch in jede Ecke vom Raum schon eine Kerze

reinstellen und so.

Das ist dann,

das ist Metaprogramming, was du da meinst.

Und Metaklasse.

Man muss immer ein bisschen aufpassen, was man damit sich

heraufbeschwört, wenn man zu viel

Meta macht, dann das kann auch.

Zu viel Magie.

Ja.