WEBVTT

00:00:00.001 --> 00:00:04.600
Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python Podcast Episode 58.

00:00:04.600 --> 00:00:06.000
Wow, 58.

00:00:06.000 --> 00:00:07.600
Ja, gar nicht so schlecht, oder?

00:00:07.600 --> 00:00:11.000
Überraschend, wir reden heute über Fluen, Python. Hi Jochen.

00:00:11.000 --> 00:00:13.400
Jo, halli, hallo Dominik. Herzlich willkommen.

00:00:13.400 --> 00:00:14.400
Und hi Johannes.

00:00:14.400 --> 00:00:15.400
Johannes, hi.

00:00:15.400 --> 00:00:16.400
Schön, dass ihr da seid.

00:00:16.400 --> 00:00:18.400
Ja, schön, dass ihr da seid.

00:00:18.400 --> 00:00:20.400
Wir hatten dich ja schon ein paar mal hier, habe ich gehört.

00:00:20.400 --> 00:00:24.400
Ich wahrscheinlich, ich glaube ein oder zweimal oder so ungefähr dabei.

00:00:24.400 --> 00:00:27.400
Ja, glaube ich auch. Anderthalb oder so.

00:00:27.400 --> 00:00:32.400
Wir wollen heute über ein Buch sprechen, Fluen, Python von Luciano Darmalho.

00:00:32.400 --> 00:00:34.400
Richtig ausgesprochen? Ich weiß nicht genau.

00:00:34.400 --> 00:00:37.400
Ja, oder das haben wir so ein bisschen als Vorlage hergenommen.

00:00:37.400 --> 00:00:45.400
Ich würde eher denken, wir, also es wurde, es wurde, wir haben, uns erreichten, genau, uns erreichten irgendwie Zuschriften,

00:00:45.400 --> 00:00:49.400
die sagten, ah, mach doch mal ein bisschen was mehr für Anfänger und irgendwie mehr.

00:00:49.400 --> 00:00:51.400
Und dann hast du dir das tollste Buch ausgedrückt, wo du dann.

00:00:51.400 --> 00:00:54.400
Mein, mein, mein tatsächlich mein Lieblings, Lieblings Python Buch.

00:00:54.400 --> 00:00:57.400
Und dann dachte ich, ah ja, da kann man ja vielleicht mal so ein bisschen durchgehen.

00:00:57.400 --> 00:01:01.400
Ich lese mal kurz aus dem Buch vor, weil du sagtest, Anfänger.

00:01:01.400 --> 00:01:02.400
Anfänger, Jochen.

00:01:02.400 --> 00:01:05.400
"If you are just learning Python, this book is going to be hard to follow.

00:01:05.400 --> 00:01:13.400
Not only that, if you read it too early in your Python learning, it may give you the benefit that every Python script should leverage special methods and metaprogramming tricks" und so weiter.

00:01:13.400 --> 00:01:17.400
Also das steht für alle Leute, die es nicht verstanden haben, es ist kein Anfängerbuch.

00:01:17.400 --> 00:01:19.400
Ja, ja gut, aber wir machen ja jetzt nicht Metaprogramming.

00:01:19.400 --> 00:01:22.400
Also Metaprogramming Zeugs ist ja auch drin, aber das machen wir ja jetzt gar nicht.

00:01:22.400 --> 00:01:23.400
Noch nicht.

00:01:23.400 --> 00:01:26.400
Okay, dann steigen wir leicht ein mit Datenstrukturen oder sowas.

00:01:26.400 --> 00:01:30.400
Genau, wir fangen jetzt mit so ganz grundlegenden Dingen dann an.

00:01:30.400 --> 00:01:33.400
Nicht, dass wir Struktur hätten in dieser Folge, aber wir versuchen es heute.

00:01:33.400 --> 00:01:34.400
Ja, wir so ein bisschen.

00:01:34.400 --> 00:01:37.400
Also wir hatten ja auch schon mal was zu Dicts gemacht und zu Listen.

00:01:37.400 --> 00:01:38.400
Ja, das ist schon spannend.

00:01:38.400 --> 00:01:39.400
Und ich weiß nicht, ob wir Strings hatten.

00:01:39.400 --> 00:01:40.400
Hatten wir, glaube ich, noch nicht.

00:01:40.400 --> 00:01:44.400
Also wir haben darüber schon öfter gesprochen, aber ich glaube, wir haben tatsächlich noch keine Folge dazu gemacht.

00:01:44.400 --> 00:01:46.400
Steht noch auf unserer Möchten-wir-gerne-machen-Liste.

00:01:46.400 --> 00:01:48.400
Aber vielleicht erst mal zu News.

00:01:48.400 --> 00:01:51.400
Gibt es denn was Neues in Python, in der Python-Community oder in Python selbst?

00:01:51.400 --> 00:01:55.400
Ja, seitdem wir das letzte Mal aufgenommen haben, ist nicht so wahnsinnig viel passiert.

00:01:55.400 --> 00:01:56.400
Ist jetzt auch gar nicht mehr.

00:01:56.400 --> 00:01:57.400
Letzte Woche war EuroPython, Jochen.

00:01:57.400 --> 00:02:01.400
Ach ja, ja, EuroPython. Wie war denn die EuroPython? War gut, hat Spaß gemacht.

00:02:01.400 --> 00:02:06.400
Ja, war cool. Hat sehr viele nette Leute kennengelernt und mit ihnen geschnackt, wie das halt so ist.

00:02:06.400 --> 00:02:08.400
Ich weiß aber nicht, ob das einen News-Charakter hat.

00:02:08.400 --> 00:02:10.400
Also außer mich persönlich natürlich.

00:02:10.400 --> 00:02:16.400
Was ich sehr genossen habe, war tatsächlich Lukas Schlanger und der Python-Rappel-3.13-Talk,

00:02:16.400 --> 00:02:24.400
der quasi der letzte war vor der Abschlussrede, wo man so ein bisschen interaktive Möglichkeiten sehen konnte von denen, was so möglich ist.

00:02:24.400 --> 00:02:31.400
Das war so ein bisschen eine Mischung aus iPython mit Bund und man konnte richtig coole Sachen machen und bei den Dingen so fancy stuff.

00:02:31.400 --> 00:02:33.400
Ist so ein bisschen Spaß-Talk gewesen.

00:02:33.400 --> 00:02:37.400
Also er hat dabei Musik gemacht, hat Eurorec angeschlossen und seine MIDI-Synthesizer damit bedient.

00:02:37.400 --> 00:02:42.400
Also genau, war mein Ding. Fallen die Talks raus, schaut doch mal rein. Das ist mit Sicherheit sehr nett.

00:02:42.400 --> 00:02:49.400
Und was ich auch ganz gut fand, war, wir haben alle relativ viel darüber diskutiert, was Armin Rohnachar so erzählt hat zu,

00:02:49.400 --> 00:02:53.400
was scheiße läuft in Python und zwar das ganze Packaging-Ding und so.

00:02:53.400 --> 00:02:59.400
Das wissen wir wahrscheinlich alle derselben Meinung, dass das da irgendwann mal so ein Tool geben könnte,

00:02:59.400 --> 00:03:01.400
dass sowas macht wie vielleicht Cargo für Rust oder so.

00:03:01.400 --> 00:03:09.400
Ja, der Meinung bin 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.

00:03:09.400 --> 00:03:10.400
Okay, aber das ist ja was anderes.

00:03:10.400 --> 00:03:12.400
Aber da gibt es auch schon 23 Tools, die sowas machen.

00:03:12.400 --> 00:03:15.400
Ja, genau, das ist der Punkt. Armin meinte auch, da gibt es halt noch ein 24. Das ist jetzt.

00:03:15.400 --> 00:03:19.400
Aber das ist so ein altes XKCD-Comic.

00:03:19.400 --> 00:03:23.400
Aber das ist so ein bisschen, vielleicht doch.

00:03:23.400 --> 00:03:28.400
Also vielleicht sollte man einfach miteinander reden und vielleicht doch so ein Ding bauen, was dann übrig bleibt.

00:03:28.400 --> 00:03:38.400
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,

00:03:38.400 --> 00:03:46.400
irgendwie so schön nutzbar macht, dass irgendjemand, der das noch alles nicht kennt, einfach mal so ein Curl macht auf so eine Installation

00:03:46.400 --> 00:03:48.400
und dann hat er ein Tool, mit dem das alles geht.

00:03:48.400 --> 00:03:53.400
Das wäre schon ziemlich gut. Also so vom Pain-Faktor her.

00:03:53.400 --> 00:03:58.400
Und immer dann, wenn ich jetzt Leuten versucht habe, das beizubringen oder versucht habe, bei denen Python zu installieren

00:03:58.400 --> 00:04:03.400
oder auf so einer Schulung irgendwie kleine Sachen mit denen machen wollte oder die zum ersten Mal so einen Notebook in die Hand nehmen wollten

00:04:03.400 --> 00:04:09.400
oder irgendwie irgendwas anderes, das war immer Schmerzen damit verbunden.

00:04:09.400 --> 00:04:11.400
Und da ja Rust gerade so.

00:04:11.400 --> 00:04:15.400
Nein, eigentlich ist das ganz einfach. Also du musst folgende Sachen installieren.

00:04:15.400 --> 00:04:17.400
Das ist wirklich nur eine sehr kurze Liste.

00:04:17.400 --> 00:04:27.400
Also erstmal brauchst du Build Essentials und dann brauchst du die ganzen Abhängigkeiten und LibJPG und LibJPG 98 und LibJPG 2K

00:04:27.400 --> 00:04:31.400
und dann musst du PyEnv installieren und dann bist du schon fast so weit.

00:04:31.400 --> 00:04:33.400
Und dann Apple und eine Banane und wie auch immer sagt, die ganzen Dschungel.

00:04:33.400 --> 00:04:40.400
Und ja, also ich habe am Sprint dann für PyRun so ein paar Sachen installiert, weil ich es kompilieren wollte.

00:04:40.400 --> 00:04:43.400
Es hat tatsächlich drei Stunden gedauert, bis es kompiliert ist auf meinem Tool langsam.

00:04:43.400 --> 00:04:47.400
Klasse. Aber so ist das manchmal.

00:04:47.400 --> 00:04:56.400
Ja, also ich bin mal gespannt. Also ich habe ja auch schon dann irgendwie gehört, was Leute dazu sagen, die sich mit diesem ganzen Thema schon lange beschäftigen.

00:04:56.400 --> 00:05:04.400
Und es gab auch schon mehrere Versuche, das zu vereinheitlichen und da auch Peps zu etablieren, die quasi das standardisieren.

00:05:04.400 --> 00:05:06.400
Und die sind gescheitert alle bisher.

00:05:06.400 --> 00:05:14.400
Auch das letzte Mal, wie heißt der jetzt noch? Einer der bekanntesten Python-Core-Entwickler, der halt auch da irgendwie so ein großes Team bei Microsoft leitet.

00:05:14.400 --> 00:05:18.400
Der große Kanadier, wie heißt der noch? Na, ich habe den Namen vergessen. Keine Ahnung.

00:05:18.400 --> 00:05:25.400
Auf jeden Fall, der hat da versucht einen Peps zu machen, das hat halt gescheitert, weil ja, also mit dem Fazit, es geht nicht.

00:05:25.400 --> 00:05:31.400
Ami 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.

00:05:31.400 --> 00:05:38.400
Okay, ich bin gespannt. Also wenn das dann funktioniert, dann lasst mich überzeugen. Aber das, ja gut, werden wir dann sehen.

00:05:38.400 --> 00:05:48.400
Was auch interessant ist, es gibt einmal diese UV-Geschichte, da gibt es dann auch noch diese Firma von Charlie Marsh, die hat ja jetzt irgendwie übernommen, das zu maintainen, das UV.

00:05:48.400 --> 00:05:52.400
Ja, genau. Ja, also UV und Rye, wer ist das von einem?

00:05:52.400 --> 00:05:56.400
Der hat nicht UV übernommen, sondern Rye.

00:05:56.400 --> 00:06:05.400
Die integrieren sich tatsächlich relativ, die reden auch voneinander und übereinander und so und die integrieren einander relativ viel und Rye benutzt das UV statt PIP-Tools, glaube ich, oder so,

00:06:05.400 --> 00:06:15.400
und über, dann darüber, das sieht alles gar nicht so schlecht aus und die Firma ist, glaube ich, Astral oder so und die machen auch Ruff und das, was eigentlich auch relativ gut funktioniert, finde ich.

00:06:15.400 --> 00:06:32.400
Ja, die machen so eben ganz viel in Rust. Gibt es auch eine Firma hier, also es gibt ja da irgendwie auch eine schnellere Alternative zu Conda, Mamba von Prefix-Dev oder weiß ich nicht, Wolf Vollprecht oder so, den könnten wir vielleicht auch mal, den können wir doch mal zu diesem Thema fragen.

00:06:32.400 --> 00:06:34.400
Ja, du weißt ja gerade, dass du für dich zuhörst.

00:06:34.400 --> 00:06:50.400
Ja, und genau, genau, und das kommt da auch irgendwie mit rein, 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 gespannt.

00:06:50.400 --> 00:06:55.400
Ja, und ich finde es auch gut, dass man tatsächlich jetzt echt irgendwann durch ist mit diesem ganzen, das nervt.

00:06:55.400 --> 00:07:07.400
Und vielleicht also Standards, also ich mag ja zum Beispiel diesen Go nicht, weil zu viel Standard und so, da ist immer zu viel Opinion und so. Und dann, okay, dann nutzt man dann doch Black. Aber vielleicht gibt es da so ein paar…

00:07:07.400 --> 00:07:09.400
Moment, das habe ich nicht verstanden, was?

00:07:09.400 --> 00:07:21.400
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, Tubs instead of Spaces, weil ich will das so, wenn ich das anders möchte.

00:07:21.400 --> 00:07:27.400
Und das nervt mich immer so ein bisschen, weil das da schon ein Python ist, ist halt dynamisch, ich kann es mir nicht aussuchen, wie ich es mache.

00:07:27.400 --> 00:07:39.400
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.

00:07:39.400 --> 00:07:40.400
Ja.

00:07:40.400 --> 00:07:43.400
Ja, okay, na gut, kann man machen, wie man will.

00:07:43.400 --> 00:07:49.400
Ja, also ich meine, aber wenn man jetzt bei Black dann irgendwie ein Konfigurationsdatei jedes Mal beschieben muss, ist das halt auch irgendwie Art und Absurdung, ne?

00:07:49.400 --> 00:07:53.400
Ja, genau, weil Black gibt es das halt nicht, genau, dann muss halt was anderes sein, gibt ja auch noch andere.

00:07:53.400 --> 00:08:01.400
Das ist so eine Sache, die denke ich mir schon lange, dass eigentlich diese ganze Codeformatting-Debatte, die ist doch Quatsch, oder?

00:08:01.400 --> 00:08:02.400
Ja.

00:08:02.400 --> 00:08:11.400
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.

00:08:11.400 --> 00:08:12.400
Ja, genau.

00:08:12.400 --> 00:08:23.400
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.

00:08:23.400 --> 00:08:28.400
Das ist so ein bisschen so, da müsste mal jemand was machen.

00:08:28.400 --> 00:08:32.400
Da kommt dann immer der Einwand, dann mach doch mal was dagegen, dann sage ich, naja.

00:08:32.400 --> 00:08:39.400
Naja, das Problem ist halt, wie kriegst du denn aus dem AST wieder was, wenn du jetzt tatsächlich was manuell anderes haben willst.

00:08:39.400 --> 00:08:48.400
Möchtest du eine VR-Brille aufziehen und dann hast du vor dir den einen Balken, den einen Graphen und hast die Notes, musst du an der durchmaschinen, kannst du dich auf dein Laufband stellen und hinlaufen?

00:08:48.400 --> 00:08:54.400
Ne, also da gibt es bestimmt Leute, die das so wollen, aber ich will ja nicht laufen, ich bin ja ein Softwareentwickler.

00:08:54.400 --> 00:09:10.400
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, das ist doch auch völlig egal.

00:09:10.400 --> 00:09:16.400
Wenn Leute lieber Braces haben wollen, dann sollen sie halt sich ihren Editor so einstellen, dass der die Blöcke mit Braces umfasst.

00:09:16.400 --> 00:09:29.400
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?

00:09:29.400 --> 00:09:31.400
Ja, also ein Grund, der mir jetzt sofort,

00:09:31.400 --> 00:09:34.400
Das ist so eine Debatte, die jetzt auch in die, ins Gebüsch führt.

00:09:34.400 --> 00:09:43.400
Ja, also ein Grund, der mir direkt so einfallen würde, ist halt, was ist, weil das hatte ich jetzt letztens, ist halt, was ist, wenn ich Dinge anders machen möchte als jeder andere?

00:09:43.400 --> 00:09:46.400
Du meinst Innovation?

00:09:46.400 --> 00:09:48.400
Nein, einfach optisch.

00:09:48.400 --> 00:09:49.400
Müll. Achso, äh, Entschuldigung.

00:09:49.400 --> 00:09:56.400
Ja, das muss doch dein Editor können, das muss doch deine, das muss doch eine Einstellungssache bei dir sein, weil am Ende kommt ja der gleiche Preissencode raus.

00:09:56.400 --> 00:10:06.400
Ja, weil wenn jetzt, wenn jetzt sozusagen, du kriegst jetzt Code von jemand anders, wie soll denn das, so wie ich das sehen will, wie soll der denn da hin transformiert werden?

00:10:06.400 --> 00:10:08.400
Das kannste nur machen, wenn du das Modell machst.

00:10:08.400 --> 00:10:13.400
In der Standardform geht leicht, aber der umgekehrte Weg geht halt nicht. Oder?

00:10:13.400 --> 00:10:16.400
Ich glaub, das geht, ich glaub, das geht in alle Richtungen.

00:10:16.400 --> 00:10:17.400
Hm.

00:10:17.400 --> 00:10:31.400
Aber das wäre halt das, was da zu beweisen wäre. Und ich glaube, dass die, die, äh, die richtige Darstellungsart eben nicht Text in Ascii oder Unicode ist, sondern halt ein strukturierteres Modell.

00:10:31.400 --> 00:10:35.400
Und aus diesem strukturierteren Modell kannst du dann ja mehr Sachen auch rausziehen.

00:10:35.400 --> 00:10:43.400
Ja, gut, aber es ist unbewiesen. Ja, das ist hier so ein, wie gesagt, so ein "Jemand sollte das mal tun"-Projekt.

00:10:43.400 --> 00:10:44.400
Ja.

00:10:44.400 --> 00:10:48.400
In meiner vierstelligen Liste der Nebenprojekte ist es nicht auf Platz eins.

00:10:48.400 --> 00:10:53.400
Also, jedenfalls, ich wollte eigentlich für Standards an der Stelle sprechen, weil ich tatsächlich finde, dass das so ein bisschen anstrengend ist.

00:10:53.400 --> 00:11:03.400
Und das wäre schon gut, wenn so ein Standard das so löst, dass diese ganzen Pains und Probleme, ne, eine Lösung haben, die tatsächlich von allen so mitgetragen wird.

00:11:03.400 --> 00:11:05.400
Das wäre schon irgendwie nice to have.

00:11:05.400 --> 00:11:11.400
Also so ein "Kolorabotivespiel", äh, "Kolorabotivespiel", boah, Zungenbrecher. Ihr wisst, was ich meine.

00:11:11.400 --> 00:11:12.400
"Kolorabotivespiel"?

00:11:12.400 --> 00:11:13.400
Ja.

00:11:13.400 --> 00:11:15.400
Aber du meinst jetzt für Codeformat?

00:11:15.400 --> 00:11:16.400
Äh, nein.

00:11:16.400 --> 00:11:17.400
Ach so, okay.

00:11:17.400 --> 00:11:18.400
Ich meine für Packaging.

00:11:18.400 --> 00:11:19.400
Packaging.

00:11:19.400 --> 00:11:27.400
Und also Installation und Python generell und Binarys verteilen und Setup und Venfs und Dependencies und sowas alles.

00:11:27.400 --> 00:11:42.400
Naja, ich hab 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.

00:11:42.400 --> 00:11:45.400
Ja, das Problem ist halt, man will sich aber damit gar nicht beschäftigen.

00:11:45.400 --> 00:11:49.400
Doch, doch, da haben sich, oh yeah, da haben sich viele Leute ganz lange damit beschäftigt.

00:11:49.400 --> 00:11:55.400
Ich möchte mich nicht damit beschäftigen, was für Probleme Python beim Package installieren beim Venf hat, sondern ich möchte Packages installieren, die die benutzen.

00:11:55.400 --> 00:11:56.400
Ja, aber ...

00:11:56.400 --> 00:11:57.400
Weil ich möchte halt Programme schreiben.

00:11:57.400 --> 00:12:01.400
Ja, aber die Frage ist, ist das überhaupt möglich bei einer so alten Sprache? Geht das?

00:12:01.400 --> 00:12:08.400
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.

00:12:08.400 --> 00:12:11.400
Und weil man all die Dinge, die man früher bei Python gemacht hat, da halt nicht drin hat.

00:12:11.400 --> 00:12:13.400
Ja, aber da müssen wir auftimmen, Michel, das sind also ...

00:12:13.400 --> 00:12:14.400
So jung ist Rust jetzt auch.

00:12:14.400 --> 00:12:23.400
Das Problem ist, das war, das ist ja, ja, aber ein Großteil von dem Zeug, das verwendet wird, ist halt älter als 20 Jahre und macht Dinge, die total komisch sind.

00:12:23.400 --> 00:12:24.400
Und dann ...

00:12:24.400 --> 00:12:25.400
Was hier?

00:12:25.400 --> 00:12:26.400
Ja.

00:12:26.400 --> 00:12:30.400
Johann, was würdest du sagen, wann ist Rust erschienen, wann war das erste Release von Rust?

00:12:30.400 --> 00:12:32.400
Ich glaube, das ist etwas mehr als zehn Jahre her.

00:12:32.400 --> 00:12:33.400
Na ja, nicht ...

00:12:33.400 --> 00:12:35.400
So irgendwann 2013, 2015?

00:12:35.400 --> 00:12:37.400
15. Mai 2015, also neun Jahre.

00:12:37.400 --> 00:12:38.400
Ah, okay.

00:12:38.400 --> 00:12:39.400
Na gut, okay.

00:12:39.400 --> 00:12:40.400
Nicht so schlecht.

00:12:40.400 --> 00:12:41.400
Hab ich sogar ein bisschen zu alt geschätzt, ja.

00:12:41.400 --> 00:12:44.400
Ja, okay, aber also ganz junge Sprache ist es auch nicht mehr.

00:12:44.400 --> 00:12:47.400
Nee, aber viel, viel jünger als Python, viel, viel jünger, ja.

00:12:47.400 --> 00:12:48.400
Ja, gut, das stimmt natürlich.

00:12:48.400 --> 00:12:52.400
Wobei Python 3 ist jetzt auch noch nicht, ist doch auch erst seit ein paar Jahren.

00:12:52.400 --> 00:12:53.400
Ja.

00:12:53.400 --> 00:12:57.400
Ich sag ja immer, Zeit für Python 4.

00:12:57.400 --> 00:12:58.400
Okay, ja.

00:12:58.400 --> 00:13:01.400
Die nächste Version ist Python 8, oder?

00:13:01.400 --> 00:13:06.400
Da gab es doch mal so einen April-Scherz, so ein Pep, wie die nächste Python-Version heißen sollte.

00:13:06.400 --> 00:13:08.400
Und dass man dann immer additiv vorgeht.

00:13:08.400 --> 00:13:12.400
Der große Vorteil von dem Versionsschema ist, dass man alle anderen Versionen einholt.

00:13:12.400 --> 00:13:14.400
Das war auch ein lustiger Talk.

00:13:14.400 --> 00:13:17.400
Wer ist nochmal der Release-Manager von 13 und 14, wisst ihr?

00:13:17.400 --> 00:13:19.400
Äh, Thomas Wotors?

00:13:19.400 --> 00:13:21.400
Kann der auf jeden Fall, ja.

00:13:21.400 --> 00:13:27.400
Ich meine, der war auch lustig, weil er meinte nämlich, er möchte gerne das Versioning von Python ändern,

00:13:27.400 --> 00:13:29.400
einfach auf Jahreszahlen anpassen.

00:13:29.400 --> 00:13:34.400
Dann wäre es halt demnächst Python 24 einfach, dann Python 25.

00:13:34.400 --> 00:13:39.400
Und dann aber mit drei davon, wenn man drei behalten würde, dann 3 von 25, weil es Blut wäre.

00:13:39.400 --> 00:13:44.400
Da müssen Sie sich aber auch noch irgendwelche lustigen Tiernamen ausdenken, die da dazu passen.

00:13:44.400 --> 00:13:45.400
Ja.

00:13:45.400 --> 00:13:47.400
Und bitte alphabetisch aufsteigend.

00:13:47.400 --> 00:13:49.400
Ja, genau, so ungefähr.

00:13:49.400 --> 00:13:51.400
Ja, das war dann die Debatte.

00:13:51.400 --> 00:13:56.400
Ja, also es gab viel Spaß und die Talks sind sicher auch irgendwann bald da, die kann man sich alle angucken.

00:13:56.400 --> 00:14:00.400
Es gab ja verschiedene Facts, der DataTrack war relativ viel vertreten wieder.

00:14:00.400 --> 00:14:04.400
LLMs und so sind ja wie immer hoch dabei.

00:14:04.400 --> 00:14:09.400
Ich hatte nicht das große Glück, dass ich jetzt da so einen Talk erwischt hatte, der mich so total faszinierte.

00:14:09.400 --> 00:14:12.400
Die waren immer sehr, ich sag mal High-Level, was auch nicht schlecht sein muss.

00:14:12.400 --> 00:14:18.400
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

00:14:18.400 --> 00:14:22.400
oder mit dem Feintunen, das noch ein bisschen effektiver sein kann und nicht so viel Speicher dafür braucht oder so.

00:14:22.400 --> 00:14:25.400
Aber das müssten wir uns eigentlich mal für eigene Episoden irgendwann aufheben.

00:14:25.400 --> 00:14:26.400
Mhm.

00:14:26.400 --> 00:14:27.400
So was.

00:14:27.400 --> 00:14:31.400
Ja, was haben wir noch, Jochen?

00:14:31.400 --> 00:14:38.400
Ah ja, jetzt wo es um EuroPython ging, was mir eingefallen ist, wir hatten ja letztes Mal auch über die DjangoCon Europe 2024 geredet.

00:14:38.400 --> 00:14:41.400
Und die Vorträge sind jetzt online, kann man sich angucken.

00:14:41.400 --> 00:14:46.400
Und da bin ich jetzt gerade dran, die so ein bisschen nach und nach anzugucken, die ich interessant finde.

00:14:46.400 --> 00:14:48.400
Und da habe ich auch schon Interessante gesehen.

00:14:48.400 --> 00:14:56.400
Da war auch jetzt diese Woche, war ein Treffen der Django-Cologne-Usergroup.

00:14:56.400 --> 00:15:02.400
Wo es dann halt auch einen Vortrag gab über Background-Tasks, was ganz interessant war.

00:15:02.400 --> 00:15:05.400
Und ja, das klingt alles tatsächlich ziemlich interessant.

00:15:05.400 --> 00:15:07.400
Also da haben sich schon Gedanken über das Interface gemacht.

00:15:07.400 --> 00:15:08.400
Salary ID.

00:15:08.400 --> 00:15:10.400
Ja, könnte sein.

00:15:10.400 --> 00:15:12.400
Was eine gute Sache wäre.

00:15:12.400 --> 00:15:14.400
Ja, und es wäre richtig gut.

00:15:14.400 --> 00:15:19.400
Ah ja, aber da wollte ich noch sagen, weil du gesagt hast, die ganzen Talks gucken, das war tatsächlich auch super.

00:15:19.400 --> 00:15:21.400
Ich mag dieses hybride Format von Konferenzen.

00:15:21.400 --> 00:15:28.400
Auch bei der Europe Heistung konnte man halt abends, wenn man schon durch war von dem ganzen Tag und die ganzen Konferenzen live gesehen hat,

00:15:28.400 --> 00:15:34.400
sich nochmal den Track von den Sachen, die man verpasst hatte, bei YouTube auf anderthalbfach angucken zum Einschlafen oder zum Runterkommen.

00:15:34.400 --> 00:15:36.400
Ja, das war natürlich praktisch.

00:15:36.400 --> 00:15:38.400
Das heißt, man kann alle Sachen parallel gucken gleichzeitig.

00:15:38.400 --> 00:15:40.400
Oder länger frühstücken, wenn man mag.

00:15:40.400 --> 00:15:42.400
Was nicht schön ist.

00:15:42.400 --> 00:15:44.400
Sehr zu empfehlen, sehr zu empfehlen.

00:15:44.400 --> 00:15:49.400
Ja, ansonsten so in Ermangelung von Dingen, die jetzt mit Falten so viel zu tun haben.

00:15:49.400 --> 00:16:00.400
Was mich hier gerade so noch ein bisschen umtreibt, ist halt, ach ja, es war bald Urlaub und ich habe ein bisschen neue Hardware irgendwie mir zugelegt.

00:16:00.400 --> 00:16:02.400
Jochen, das ist keine Werbeveranstaltung hier.

00:16:02.400 --> 00:16:11.400
Ne, aber was ganz cool ist, es gibt jetzt so einen, tatsächlich, also dieser Haushalt enthält Computer, kann Spuren von Computern enthalten.

00:16:11.400 --> 00:16:17.400
Und der schnellste Computer in diesem Haushalt ist jetzt ein iPad.

00:16:17.400 --> 00:16:23.400
Und ja, also da sind ja diese M4-Dinger drin, die sind sackschnell. Also das ist unglaublich.

00:16:23.400 --> 00:16:25.400
Also lässt du das jetzt deine Machine Learning Modelle tunen?

00:16:25.400 --> 00:16:28.400
Aber das ist doch kein General Purpose Computer.

00:16:28.400 --> 00:16:29.400
Ne, leider nicht.

00:16:29.400 --> 00:16:31.400
Es ist argumentiert, dass es kein General Purpose Computer ist.

00:16:31.400 --> 00:16:39.400
Ja, das ist blöd. Aber es wäre voll cool, wenn es ein General Purpose Computer wäre, weil es wäre nämlich der schnellste, den ich hätte.

00:16:39.400 --> 00:16:43.400
Bau doch einfach die CPU aus. Kannst du nicht woanders einlöten?

00:16:43.400 --> 00:16:53.400
Ne, genau. Also ja, das ist so ein bisschen so, weil das Ding ist tatsächlich, also M4 gibt es auch noch in keinem anderen Gerät von Apple, also nur im iPad.

00:16:53.400 --> 00:17:03.400
Ja, es ist schon so ein bisschen traurig. Es gab auch eine Tastatur diesmal mit einer Escape-Taste, sodass halt irgendwie mit der Escape-Taste kannst du eigentlich auf iOS überhaupt gar nichts anfangen.

00:17:03.400 --> 00:17:09.400
Weil halt viele Leute gedacht haben, es kommt irgendwann MacOS für iPad, was voll cool wäre, aber nein, kam nicht.

00:17:09.400 --> 00:17:14.400
Und jetzt habe ich ein iPad und kann es nicht benutzen. Ein bisschen doof.

00:17:14.400 --> 00:17:17.400
Aber ja, ansonsten wirklich sehr schnell.

00:17:17.400 --> 00:17:18.400
Da kannst du schnell YouTube gucken.

00:17:18.400 --> 00:17:20.400
Ja, genau.

00:17:20.400 --> 00:17:26.400
Ich habe noch so eine Platine mitgebracht, die kann man sich ankleben mit so einem Magneten und da kann man so einen Text hin und her laufen lassen.

00:17:26.400 --> 00:17:27.400
Ne.

00:17:27.400 --> 00:17:29.400
Und da gibt es so ein Python-Modul, da kann man dann den Text auswählen.

00:17:29.400 --> 00:17:31.400
Und das ist dein schnellster Computer?

00:17:31.400 --> 00:17:33.400
Pst.

00:17:33.400 --> 00:17:45.400
Ja, genau. Und ja, ansonsten gab es noch so ein bisschen irgendwie, ja, LLM-Krams.

00:17:45.400 --> 00:17:47.400
Ja, da gibt es doch immer was, oder?

00:17:47.400 --> 00:17:51.400
Ja, also Xopic hat toll neue Modelle rausgebracht, die ziemlich beeindruckend sind.

00:17:51.400 --> 00:17:59.400
Ja, und Mistral hat jetzt, ich glaube, heute ein neues Modell rausgebracht, Nemo heißt das, mit einem neuen Embedding.

00:17:59.400 --> 00:18:04.400
Die haben einen neuen Embedder trainiert, der wohl deutlich besser ist.

00:18:04.400 --> 00:18:06.400
Das müsste man sich mal anschauen.

00:18:06.400 --> 00:18:10.400
Und dieses Nemo-Modell hört sich auch interessant an, das ist in Zusammenarbeit mit Nvidia entstanden.

00:18:10.400 --> 00:18:12.400
Ach, du hast ja O/A.

00:18:12.400 --> 00:18:14.400
Das ist ein 12b-Modell.

00:18:14.400 --> 00:18:22.400
Das ist also etwas größer als diese 7b-Modelle und das ist wohl genau so trainiert, dass du es auf einer normalen Grafikkarte laufen lassen kannst.

00:18:22.400 --> 00:18:24.400
Also auf einer 4090.

00:18:24.400 --> 00:18:28.400
Ja, die haben ja alle 11, 12 Gigabyte Hauptspeicher.

00:18:28.400 --> 00:18:34.400
Genau. Und das ist wohl auch schon so trainiert, dass es mit FP8 geht, ohne Leistungsabfall.

00:18:34.400 --> 00:18:37.400
Und das ist natürlich direkt sehr praktisch.

00:18:37.400 --> 00:18:46.400
Ja, ich habe auch letztens gesehen, dass irgendjemand quasi, war das Microsoft Research, ich weiß es nicht, hatte Paper veröffentlicht,

00:18:46.400 --> 00:19:00.400
zu einem Modell, das die gleiche Performance, oder sogar eine deutlich bessere Performance über viele unterschiedliche Benchmarks hingekriegt hat als GPT 3.5,

00:19:00.400 --> 00:19:02.400
aber auf einer einzelnen GPU läuft.

00:19:02.400 --> 00:19:04.400
Also auf so einer Computersumma-GPU.

00:19:04.400 --> 00:19:11.400
Und das war auch zum ersten Mal, dass es jemand geschafft hat, quasi GPT 3.5 auf so Konsumer-Hardware zu schlagen.

00:19:11.400 --> 00:19:13.400
Und das ist auch sehr beeindruckend.

00:19:13.400 --> 00:19:21.400
Also du kannst da wirklich auf deinem Rechner zu Hause Sachen laufen lassen, lokal, auf deiner Spiele-Grafikkarte,

00:19:21.400 --> 00:19:27.400
die halt irgendwie das GPT vom Anfang deutlich schlagen.

00:19:27.400 --> 00:19:30.400
Und das ist interessant. Also, ja, das geht voran.

00:19:30.400 --> 00:19:39.400
Ja, da tun sich doch viele Dinge. Das ist schön, dass da so, auch so völlig, sag ich mal, normale Sachen,

00:19:39.400 --> 00:19:45.400
dass sich jetzt hier GPT 4 und 4.0 und so, dass die sich weiterentwickeln und Cloud Sonnet und so weiter.

00:19:45.400 --> 00:19:51.400
Achso, und das Mistral Nemo-Modell hatten ein 128k-Kontakts-Window.

00:19:51.400 --> 00:19:53.400
Das ist auch eine Besonderheit.

00:19:53.400 --> 00:19:57.400
Das ist auch was Interessantes, weil die anderen lokalen Modelle hatten ja immer nur irgendwie 4k oder 8k.

00:19:57.400 --> 00:20:00.400
Und das macht doch nochmal einen deutlichen Unterschied aus.

00:20:00.400 --> 00:20:05.400
Dass sich so ganz normale Sachen, sag ich mal, weiterentwickeln, dass man eben, genau wie du sagst, Jochen,

00:20:05.400 --> 00:20:11.400
dass jetzt auf normalen GPUs laufen lassen kann und dass die Modelle größer und schneller und trotzdem skalierbar werden.

00:20:11.400 --> 00:20:15.400
Und dass es auch in der Richtung Entwicklung gibt, das finde ich eigentlich ziemlich cool.

00:20:15.400 --> 00:20:24.400
Das es nicht nur so eben in diesen Hochburgen und in den Diensteanbietern festhängt, sondern die Szene ist auch sehr lokal.

00:20:24.400 --> 00:20:29.400
Und wenn man sich da mal dieses Hugging-Face anguckt, ja, und wie viele Pflege von Lamas es gibt,

00:20:29.400 --> 00:20:36.400
und dann gibt es manche, wo das Sicherheitstraining weg ist und eins spricht nur keine Art der Sprache und eins ist nur diesen, das und jenes kann.

00:20:36.400 --> 00:20:39.400
[Gesang]

00:20:39.400 --> 00:20:41.400
Es ist schon schön, dass da was passiert.

00:20:41.400 --> 00:20:46.400
Ja, genau. Ja, und die andere Seite, also OpenAI und so, das ist auch interessant.

00:20:46.400 --> 00:20:50.400
Also überhaupt, da wollte ich auch noch wegen Apple irgendwie drauf zu sprechen kommen.

00:20:50.400 --> 00:21:00.400
Die bauen ja jetzt dann irgendwie die Dinger ein in iOS und was eingebaut wird, ist auch GPT 4.0.

00:21:00.400 --> 00:21:05.400
Also du kriegst halt jetzt, wenn du ein iPhone oder sonst irgendwas kaufst, wahrscheinlich dann ab jetzt, wenn die neuen Geräte kommen,

00:21:05.400 --> 00:21:14.400
kriegst du halt, oder eine neue iOS-Version, kriegst du halt quasi die Bezahlversion von OpenAI irgendwie in deinem Gerät.

00:21:14.400 --> 00:21:23.400
Und das 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.

00:21:23.400 --> 00:21:25.400
Ja, du hast sogar einen Bordseed.

00:21:25.400 --> 00:21:27.400
Ja, genau, die haben jetzt, der hat jetzt,

00:21:27.400 --> 00:21:31.400
Microsoft hat doch die Daten von allen iOS-Nutzern, haben sie wieder aufgegeben, sind nicht mehr.

00:21:31.400 --> 00:21:32.400
Mhm.

00:21:32.400 --> 00:21:39.400
Sowohl Microsoft als auch Apple haben ihren Bordseed aufgegeben. Es waren eh nur Beobachtende, aber es haben sich beide zurückgezogen.

00:21:39.400 --> 00:21:47.400
Achso, okay, ich dachte eigentlich, dass jetzt sozusagen das Gerücht war, dass das Feldfühler irgendwie ins Board von OpenAI geht, aber.

00:21:47.400 --> 00:21:49.400
Ja, haben sie aber wieder zurückgezogen.

00:21:49.400 --> 00:21:53.400
Ah, okay. Dann, naja, dann war ich da schon nicht mehr so aktuell. Aber ich meine.

00:21:53.400 --> 00:21:57.400
Es bewegt sich so schnell, das kannst du nicht. Wahnsinn.

00:21:57.400 --> 00:21:59.400
Falls man hinguckt, ist schon alles ganz anders.

00:21:59.400 --> 00:22:09.400
Aber naja, gut, also ich in gewisser Weise verstehe 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.

00:22:09.400 --> 00:22:14.400
Also sie haben halt einen strukturellen Nachteil gegenüber sowas wie Google oder so. Google braucht das alles nicht.

00:22:14.400 --> 00:22:18.400
Die können einfach irgendwie über Android, haben sie da halt einen riesen Hebel.

00:22:18.400 --> 00:22:25.400
Und, aber OpenAI, wenn sie halt nicht Partnerschaften mit Microsoft oder mit Apple haben, dann haben sie halt ein Problem.

00:22:25.400 --> 00:22:33.400
Weil, ja, wenn die, sonst passiert ihnen das, was halt irgendwie, keine Ahnung, Slack passiert ist mit Teams oder so, und dann sind sie halt weg.

00:22:33.400 --> 00:22:38.400
Ja, insofern, ja, es ist auf jeden Fall interessante Zeiten. Bin mal gespannt.

00:22:38.400 --> 00:22:43.400
Aber 4.0 ist auch so gut, also ich finde das hier auch dauernd, also das ist, dass das wahrscheinlich irgendwie.

00:22:43.400 --> 00:22:45.400
Ja, aber was machst du denn, Jochen? Was machst du denn damit?

00:22:45.400 --> 00:22:47.400
Ja, programmieren.

00:22:47.400 --> 00:22:51.400
Ach so, ja gut, okay, das, ich weiß nicht, da geh ich in den Flow rein.

00:22:51.400 --> 00:22:54.400
Ja, aber auch Opus, das ist schon.

00:22:54.400 --> 00:22:57.400
Ja, Opus ist auch super, also ja, absolut. Oder so nicht.

00:22:57.400 --> 00:23:03.400
Ja, du gibst halt einfach so Fragen, das stimmt dann auf einmal doch eher mehr als früher.

00:23:03.400 --> 00:23:07.400
Noch mehr als früher. Und dann, man kann es halt so steuern, wenn man halt.

00:23:07.400 --> 00:23:09.400
Bleibt das irgendwo integriert oder?

00:23:09.400 --> 00:23:13.400
Ja, ja, wenn man, also auch Konsole halt, ne.

00:23:13.400 --> 00:23:22.400
Und wenn man halt, dann kannst du halt auch pipen, mit Cut reinpipen, irgendwas, oder ein Slack dann halt, Template, mach einen PyTest drauf oder so.

00:23:22.400 --> 00:23:24.400
Und das ist gut, gute Vorschläge.

00:23:24.400 --> 00:23:33.400
Also die sind nicht immer ganz rein, aber man kann das ja auch modifizieren, kann sagen, so ja, ein bisschen mehr in, ne, bisschen mehr Fixtures, ein bisschen weniger dies, ein bisschen weniger das, wenn man das nicht schon im System schon drin stehen hat.

00:23:33.400 --> 00:23:35.400
Und dann ist das ziemlich das, was man will.

00:23:35.400 --> 00:23:40.400
Man kann ja auch so ein Beispiel geben, wie, hey, und so wie ich das hier gemacht habe, so das es ungefähr so könnte es aussehen.

00:23:40.400 --> 00:23:43.400
Und dann, fertig.

00:23:43.400 --> 00:23:51.400
Ich bin da immer 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.

00:23:51.400 --> 00:23:53.400
Vielleicht muss man sich das mal zusammensetzen.

00:23:53.400 --> 00:23:55.400
An Emax Johannes.

00:23:55.400 --> 00:24:01.400
Ich glaube, doch PyCharm, bin doch ein PyCharm-Unterstützer.

00:24:01.400 --> 00:24:05.400
Ja, aber hast du da den Copilot zum Beispiel an oder so, weil das ist auch schon ganz ok.

00:24:05.400 --> 00:24:10.400
Also ich finde ehrlich gesagt, das ist nicht so gut, wie wenn man jetzt quasi direkt mit.

00:24:10.400 --> 00:24:12.400
Wann hast du das letzte Mal probiert, Jochen?

00:24:12.400 --> 00:24:15.400
Keins dieser Systeme hat mich je überzeugt.

00:24:15.400 --> 00:24:16.400
Ok.

00:24:16.400 --> 00:24:19.400
Ich habe es ein paar Mal probiert und das war jedes Mal so, ne.

00:24:19.400 --> 00:24:21.400
Johannes hätte es besser gewusst.

00:24:21.400 --> 00:24:25.400
Das, vielleicht ist das das Problem, vielleicht weiß ich es einfach besser.

00:24:25.400 --> 00:24:26.400
Ja, ich würde es auch sagen.

00:24:26.400 --> 00:24:27.400
Ja gut, kann man genau machen.

00:24:27.400 --> 00:24:29.400
Da würde ich aber sagen, dass das genau das.

00:24:29.400 --> 00:24:33.400
Wenn der Jochen sagt, dass das bei ihm hilft, dann kann es bei mir nicht sein, dass ich es besser weiß.

00:24:33.400 --> 00:24:42.400
Also hier ist eine wundervolle Überleitung, das ist übrigens Tim Peters, der Core-Entwickler und Autor von Zen of Pison, das ihr bestimmt alle kennt, ne, Imports.

00:24:42.400 --> 00:24:48.400
Dann meinte der, der Plan wäre, wenn jemand ein Feature entwickelt, das du nicht verstehst, dann knall ihn einfach ab.

00:24:48.400 --> 00:24:52.400
Und das ist der Einstieg in das wunderschöne Buch von Flue und Pison.

00:24:52.400 --> 00:24:55.400
Ja, da muss man direkt mal klar machen, wie die Sachen dann so laufen und genau.

00:24:55.400 --> 00:24:58.400
Das ist auf jeden Fall einfacher, als etwas Neues zu lernen.

00:24:58.400 --> 00:25:02.400
Ja, und dann im Schluss hat man nur noch Leute, die irgendwie kein Problem mehr haben, das zu verstehen, was man sagt.

00:25:02.400 --> 00:25:11.400
Ja, und bevor die einzelnen überlebenden Entwickler, dann kann man ein kleines Stück von dem, was man schon kann, dann verwenden und kommt damit weiter.

00:25:11.400 --> 00:25:15.400
Also sind wir jetzt bei Flue und Pison?

00:25:15.400 --> 00:25:16.400
Sind wir jetzt bei Flue und Pison?

00:25:16.400 --> 00:25:17.400
Sind die News, ok, wir können durchschalten.

00:25:17.400 --> 00:25:25.400
Ja, ich würde tatsächlich jetzt so ein bisschen unser Ratsche versuchen, in eine Struktur zu überführen, die uns ein bisschen zurückführt auf dieses wundervolle.

00:25:25.400 --> 00:25:27.400
Äh, Python, Delta.

00:25:27.400 --> 00:25:29.400
Fluent, was heißt denn Fluent? Flüssig?

00:25:29.400 --> 00:25:31.400
Also ich wollte nicht über das Buch sprechen eigentlich.

00:25:31.400 --> 00:25:32.400
Fließend.

00:25:32.400 --> 00:25:36.400
Eigentlich wollte ich gar nicht erwähnen, das Buch, das aus dem Buch klauen, aber gut.

00:25:36.400 --> 00:25:40.400
Achso, du wolltest einfach so tun, als dass das deine, deine, ja, Entschuldigung.

00:25:40.400 --> 00:25:41.400
Na egal.

00:25:41.400 --> 00:25:43.400
Den ganzen Spaß verdauern.

00:25:43.400 --> 00:25:45.400
Ok.

00:25:45.400 --> 00:25:49.400
Ja, nee, wir können das auch sagen, das ist ja kein Problem, aber genau, was wir.

00:25:49.400 --> 00:25:50.400
Ja, die Erklärung können wir schon abgeben, finde ich, ja.

00:25:50.400 --> 00:25:58.400
Was es, was es heute im Grunde geht, ist halt wie, sie nennen das Python Data Model oder im Buch wird es auch so genannt, es wird auch in der Referenzdokumentation so genannt.

00:25:58.400 --> 00:26:01.400
Es gibt andere Leute, die nennen das irgendwie anders, Python Object Model oder so.

00:26:01.400 --> 00:26:05.400
Und im Grunde geht es darum, was ist denn das jetzt überhaupt wieder alles?

00:26:05.400 --> 00:26:06.400
Genau.

00:26:06.400 --> 00:26:07.400
Also ich tue jetzt mal einmal so, ne.

00:26:07.400 --> 00:26:08.400
Ja, ja.

00:26:08.400 --> 00:26:09.400
Also, ja.

00:26:09.400 --> 00:26:10.400
Tu mal so, als ob du das nicht wüsstest, nämlich.

00:26:10.400 --> 00:26:11.400
Ja, genau, das sage ich doch.

00:26:11.400 --> 00:26:12.400
Ja.

00:26:12.400 --> 00:26:13.400
Wie immer.

00:26:13.400 --> 00:26:33.400
Also zum Beispiel ist halt die, die, die, das ist ein super Beispiel ist halt, um da vielleicht einen Einstieg zu finden, warum sagt man in Python eigentlich irgendwie len von irgendwas, einer Collection oder so und nicht Collection Punkt len, Klammer auf, Klammer zu, wie man das jetzt vielleicht in Ruby machen würde oder so.

00:26:33.400 --> 00:26:35.400
Ich weiß ehrlich gesagt gar nicht, wie man es in Ruby macht, aber.

00:26:35.400 --> 00:26:36.400
In Java, sag einfach.

00:26:36.400 --> 00:26:37.400
In Java, in Java.

00:26:37.400 --> 00:26:38.400
Die machen das komisch.

00:26:38.400 --> 00:26:40.400
Genau, warum, warum macht man das eigentlich so?

00:26:40.400 --> 00:26:56.400
Und 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.

00:26:56.400 --> 00:27:10.400
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 das halt praktisch viel besser funktioniert.

00:27:10.400 --> 00:27:26.400
Ich verstehe jetzt meine Sache nicht, also warum ist erstens irgendwas mit Klasse und Attribut und Methode Call 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?

00:27:26.400 --> 00:27:38.400
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 immer, wie man das nennt und das ist dann die Sache des Objekts.

00:27:38.400 --> 00:27:39.400
Warum?

00:27:39.400 --> 00:27:43.400
Das ist zum Beispiel in Java so.

00:27:43.400 --> 00:27:44.400
Ja, aber warum ist das so?

00:28:40.400 --> 00:28:44.460
Auch haben es Razer, weil Einfachheit ein Wegweiser zur Wahrheit ist oder zur Schönheit

00:28:44.460 --> 00:28:45.460
oder so.

00:28:45.460 --> 00:28:49.460
Okay, Point 1 für den Ja-Wahlentwickler.

00:28:49.460 --> 00:28:50.460
Für dich.

00:28:50.460 --> 00:28:51.460
Ja.

00:28:51.460 --> 00:28:58.180
Okay, und warum ist es denn nicht auch einfach, einfach so was wie funktionale Programmierung

00:28:58.180 --> 00:29:00.580
zu machen und da Zeug zueinander hin und her zu reichen?

00:29:00.580 --> 00:29:02.580
Was fehlt einem denn da in diesem Vergleich?

00:29:02.580 --> 00:29:04.580
Funktionale Programmierung ist ja auch etwas anderes.

00:29:04.580 --> 00:29:06.580
Das gibt es auch, aber das ist etwas ganz anderes.

00:29:06.580 --> 00:29:14.800
Also das ist ja, also kann man auch machen, aber dann ist es, also das wäre, kannst du

00:29:14.800 --> 00:29:19.400
auch Pure haben, so was wie Haskell oder so, oder Erlang oder weiß ich nicht.

00:29:19.400 --> 00:29:20.400
Ah, StandardML.

00:29:20.400 --> 00:29:21.400
Ja.

00:29:21.400 --> 00:29:23.400
Das ist Haskell, ja, diese modernen.

00:29:23.400 --> 00:29:29.400
Ja, aber das ist halt ein anderes Konzept als jetzt Objektorientierung.

00:29:29.400 --> 00:29:33.400
Naja, aber wir sprechen gerade von ästhetischer Einfachheit oder so.

00:29:33.400 --> 00:29:36.400
Ja, ja, ist es auch, aber es ist halt anders.

00:29:36.400 --> 00:29:38.400
Es hat dann nur Funktionen, sozusagen.

00:29:38.400 --> 00:29:42.400
Okay, aber ich wollte kurz auf die Trade-offs hinaus, weil, warum ist das jetzt?

00:29:42.400 --> 00:29:48.400
Naja, also der Grund, warum man jetzt denken konnte, dass es halt im Titen nicht so schön

00:29:48.400 --> 00:29:51.400
ist, dass man sagt, das muss man halt auch noch so, jetzt sind wir an so Build-Ins wie

00:29:51.400 --> 00:29:53.400
Len oder so, die so ein bisschen komisch sind.

00:29:53.400 --> 00:30:01.400
Aber tatsächlich hat es halt praktisch sehr viele Vorteile, wie, naja, also einmal, du

00:30:01.400 --> 00:30:05.400
musst dir nicht für jedes Objekt merken, wie das denn jetzt nun heißt mit dieser

00:30:05.400 --> 00:30:09.400
Gebote, weil das kann ja jeder dann anders machen, das wäre ja irgendwie schlecht.

00:30:09.400 --> 00:30:13.400
Das ist zum Beispiel ein Problem, was PHP hat oder JavaScript, da heißt es manchmal

00:30:13.400 --> 00:30:16.400
Size und manchmal Length und manchmal Count.

00:30:16.400 --> 00:30:23.400
Ja, und eine andere Geschichte ist halt, es ermöglicht dir halt irgendwie so ein paar

00:30:23.400 --> 00:30:28.400
dreckige Optimierungen zu machen, die halt irgendwie die Dinge, die wirklich Zeit kosten,

00:30:28.400 --> 00:30:30.400
irgendwie deutlich schneller zu machen.

00:30:30.400 --> 00:30:36.400
Zum Beispiel, du kannst halt, da diese Sachen, so tatsächlich was Len halt macht, ist ja

00:30:36.400 --> 00:30:40.400
schon dann quasi, wenn das ein Objekt ist einer Klasse, die du erstellt hast, dann

00:30:40.400 --> 00:30:43.400
wird halt dann da Len aufgerufen.

00:30:43.400 --> 00:30:45.400
Schon doch die Methode, die geheime.

00:30:45.400 --> 00:30:50.400
Die Methode aufgerufen, aber die ist halt nicht dafür da, dass irgendwie andere die

00:30:50.400 --> 00:30:56.400
aufrufen, sondern, oder dass man die von Hand aufruft, zu Fuß oder wie auch immer,

00:30:56.400 --> 00:31:00.400
die ist halt dafür da, dass der Interpreter die aufruft, wenn man halt Len von irgendwas

00:31:00.400 --> 00:31:01.400
sagt.

00:31:01.400 --> 00:31:04.400
Und dann ruft der Interpreter die auf, aber der Interpreter kann halt auch andere Dinge

00:31:04.400 --> 00:31:05.400
tun.

00:31:05.400 --> 00:31:09.400
Der kann zum Beispiel jetzt, wenn das ein irgendwie so ein native, also ein Ding im

00:31:09.400 --> 00:31:13.400
Interpreter selber ist, also oder irgendwie ein C geschriebenes Ding, wie ein Dict oder

00:31:13.400 --> 00:31:18.400
eine Liste oder sowas ist, dann kann es halt direkt irgendwie in diesem PyObject irgendwie

00:31:18.400 --> 00:31:21.400
drauf gucken, wie lang ist denn dieses Ding und gibt es dann halt zurück und muss halt

00:31:21.400 --> 00:31:23.400
keine Methode aufrufen.

00:31:23.400 --> 00:31:26.400
Also Methodenaufrufe sind halt etwas, was halt in Python super langsam ist.

00:31:26.400 --> 00:31:30.400
Oder in allen interpretierten Programmiersprachen, die so ähnlich sind wie Python, das sind

00:31:30.400 --> 00:31:33.400
halt Funktionsaufrufe, Methodenaufrufe immer total langsam.

00:31:33.400 --> 00:31:39.400
Da ist wirklich so ein Faktor 1000 dazwischen, zwischen irgendwie reinem C und Funktionsaufruf

00:31:39.400 --> 00:31:41.400
und Python oder so.

00:31:41.400 --> 00:31:47.400
Und ja, für die ganzen Standardfälle, wo man das halt benutzt, kann der Interpreter

00:31:47.400 --> 00:31:50.400
das halt alles wegoptimieren und dann macht er das halt einfach nicht, sondern da wird

00:31:50.400 --> 00:31:52.400
gar nichts aufgerufen.

00:31:52.400 --> 00:31:57.400
Also das sind halt zwei große Vorteile, die man halt kriegt, wenn man halt ein bisschen

00:31:57.400 --> 00:31:59.400
Reinheit opfert, sozusagen.

00:31:59.400 --> 00:32:06.400
Und genau, das ist halt irgendwie diese Balance zwischen irgendwie Reinheit und funktioniert

00:32:06.400 --> 00:32:07.400
super.

00:32:07.400 --> 00:32:08.400
Und Magie.

00:32:08.400 --> 00:32:09.400
Genau, ist halt so eine Spezial.

00:32:09.400 --> 00:32:13.400
Ja, Magie mag der, mag jetzt zum Beispiel der Autor von Flute und Python an der Stelle

00:32:13.400 --> 00:32:15.400
gar nicht so gerne.

00:32:15.400 --> 00:32:22.400
Also man nennt die Dinger ja irgendwie Magic Methods auch, also dieser Magic Methods.

00:32:22.400 --> 00:32:27.400
Das finde ich eine sehr schöne Diskussion über diese Namen, über die Magic Methods

00:32:27.400 --> 00:32:29.400
und über die nicht Magic Methods.

00:32:29.400 --> 00:32:31.400
Ja, fand ich auch so.

00:32:31.400 --> 00:32:34.400
Das kommt halt so aus der Ruby Community, das wusste ich gar nicht.

00:32:34.400 --> 00:32:37.400
Ich dachte eigentlich, das gibt halt ein paar Python-Entwickler, die nennen das halt Magic

00:32:37.400 --> 00:32:40.400
Methods, die dann sagen halt Dunder Methods oder sowas.

00:32:40.400 --> 00:32:45.400
Ja, aber in der Ruby-Welt ist das wohl üblich.

00:32:45.400 --> 00:32:46.400
Und ja, aber der …

00:32:46.400 --> 00:32:49.400
Das ist der offizielle Name, oder, in Ruby?

00:32:49.400 --> 00:32:51.400
Die heißen Magic Methods.

00:32:51.400 --> 00:32:52.400
Genau.

00:32:52.400 --> 00:32:56.400
Ja, oder auch in IPython oder so heißen die ja auch irgendwie Magic und dann gibt es

00:32:56.400 --> 00:32:57.400
diverse …

00:32:57.400 --> 00:32:58.400
Aber das ist ja auch wirklich Magic.

00:32:58.400 --> 00:33:00.400
Das ist wirklich Magic, okay.

00:33:00.400 --> 00:33:04.400
Aber eigentlich sind halt eben die Python-Dinger gar nicht Magic, sondern das ist halt eigentlich

00:33:04.400 --> 00:33:07.400
völlig klar, das dokumentiert, was das ist und was das tut.

00:33:07.400 --> 00:33:10.400
Und insofern, der Autor sagt selber, okay, ich finde das nicht gut.

00:33:10.400 --> 00:33:15.400
Die sollten lieber Muggel Methoden heißen oder so, weil sie halt so unmagisch sind.

00:33:15.400 --> 00:33:16.400
Aber ja.

00:33:16.400 --> 00:33:19.400
Ja, er nennt es ja dann auch oft Special Methods einfach.

00:33:19.400 --> 00:33:20.400
Special Methods ist auch ein guter Name.

00:33:20.400 --> 00:33:25.400
Ich glaube, das, was da magisch ist, ist, dass man die implementiert und dann werden sie

00:33:25.400 --> 00:33:27.400
irgendwoher aufgerufen.

00:33:27.400 --> 00:33:30.400
Und wenn du das nicht weißt, dann ist das schon magisch.

00:33:30.400 --> 00:33:31.400
Ja, ich glaube auch.

00:33:31.400 --> 00:33:33.400
Du gibst Lenn von irgendwas ein und das wird aber was ganz anderes.

00:33:33.400 --> 00:33:35.400
Und das für Anfänger ist es nicht so wichtig, dass wenn du irgendwie so eine Methode dazu

00:33:35.400 --> 00:33:39.400
fügst, die Dinge macht, wo du nicht weißt, warum, weil das unter der Haube passiert.

00:33:39.400 --> 00:33:40.400
Aber das ist natürlich.

00:33:40.400 --> 00:33:41.400
Aber das Special war ja auch nicht.

00:33:41.400 --> 00:33:42.400
Also magisch schon gut.

00:33:42.400 --> 00:33:43.400
Das macht ja Magie.

00:33:43.400 --> 00:33:46.400
Ah, es passiert irgendwas, dann machst du einen String auf irgendein Objekt und dann

00:33:46.400 --> 00:33:49.400
kommt da irgendwas raus, weil du eine Repre-Methode beschrieben hast.

00:33:49.400 --> 00:33:50.400
Ah, Magie.

00:33:50.400 --> 00:33:55.400
Wobei das natürlich eine sehr dünne Schicht Magie ist.

00:33:55.400 --> 00:33:59.400
Wie der Jochen schon gesagt hat, da gibt es eine Liste, so viel Magie gibt es und die

00:33:59.400 --> 00:34:01.400
sieht auch so und so aus.

00:34:01.400 --> 00:34:04.400
Und im Wesentlichen ist das ja nur eine syntaktische Umformung.

00:34:04.400 --> 00:34:05.400
Syntaktische Magie.

00:34:05.400 --> 00:34:07.400
Damit, syntaktische Magie, genau.

00:34:07.400 --> 00:34:09.400
Ja, aber das ist quasi echte Magie.

00:34:09.400 --> 00:34:14.400
Ich meine, echte Magie, da fummelt jemand vor den Augen mit deinem Fingernstipsen rum

00:34:14.400 --> 00:34:18.400
und auf einmal sieht er hinter seinem Ohr eine große, goldene, begrenzte Münze.

00:34:18.400 --> 00:34:19.400
Ja, das sind Illusions.

00:34:19.400 --> 00:34:20.400
Das ist keine Magie.

00:34:20.400 --> 00:34:24.400
Das ist so ein bisschen, aber so eine taktische Magie.

00:34:24.400 --> 00:34:27.400
Ja, aber echte Magie ist doch das, was man aus Harry Potter kennt.

00:34:27.400 --> 00:34:29.400
Dann schwingst du da einen Zauberstab und dann passiert irgendwas.

00:34:29.400 --> 00:34:31.400
Die richtigen Worte, der Richter ist da.

00:34:31.400 --> 00:34:33.400
Ja, aber der Richter kann ja auch eine richtige Reihenfolge sagen.

00:34:33.400 --> 00:34:35.400
Er macht irgendwas, was thermodynamisch nicht möglich ist.

00:34:35.400 --> 00:34:37.400
Ja, genau, aber da sind wir jetzt eigentlich alle relativ einig.

00:34:37.400 --> 00:34:39.400
Das gibt es halt auch nur in Harry Potter oder in ...

00:34:39.400 --> 00:34:41.400
Ich weiß nicht, also ich finde tatsächlich ...

00:34:41.400 --> 00:34:42.400
Und in Ruby.

00:34:42.400 --> 00:34:44.400
Die Analogie auch gar nicht so schlecht für Programmieren insgesamt.

00:34:44.400 --> 00:34:47.400
Also ich meine, das ist halt, also ich meine, was ist, also man sagt irgendwie ...

00:34:47.400 --> 00:34:52.400
Du sagst die richtigen Wörter in der richtigen Reihenfolge und dann passieren Dinge.

00:34:52.400 --> 00:34:56.400
Genau, ja, ich finde, das ist gar nicht so weit hergeholt, als man das vergleicht.

00:34:56.400 --> 00:34:57.400
Deshalb sind wir alle Wizards.

00:34:57.400 --> 00:34:59.400
Ich habe auch so einen Wizard-Pullover.

00:34:59.400 --> 00:35:03.400
Es gibt auch tatsächlich Leute, die Nichtprogrammierer als Muggel bezeichnen.

00:35:03.400 --> 00:35:05.400
Also ich weiß, so weit würde ich jetzt nicht gehen vielleicht, aber ...

00:35:05.400 --> 00:35:09.400
Echt? Ich bezeichne die mal als NPCs.

00:35:09.400 --> 00:35:11.400
Ja, okay.

00:35:11.400 --> 00:35:12.400
Äh, ja.

00:35:12.400 --> 00:35:13.400
Nein.

00:35:13.400 --> 00:35:18.400
Tatsächlich das erste Beispiel in einem nicht näher benannten Buch,

00:35:18.400 --> 00:35:22.400
was ich kürzlich gelesen habe, das hat mich tatsächlich etwas überrascht.

00:35:22.400 --> 00:35:24.400
Da war tatsächlich ein bisschen Magie drin.

00:35:24.400 --> 00:35:28.400
Und zwar, da wird ein Card-Deck implementiert.

00:35:28.400 --> 00:35:29.400
Ja.

00:35:29.400 --> 00:35:32.400
Und er implementiert nur zwei von diesen Methoden.

00:35:32.400 --> 00:35:34.400
Ja, für Kartentricks dann.

00:35:34.400 --> 00:35:39.400
Und er implementiert nur zwei Methoden, nämlich dann den Len und dann den Get-Item.

00:35:39.400 --> 00:35:40.400
Ja.

00:35:40.400 --> 00:35:44.400
Und das reicht aus für Slicing und Ranges und Worst und Iteration.

00:35:44.400 --> 00:35:45.400
Ja, ja, voll cool.

00:35:45.400 --> 00:35:49.400
Das hat mich etwas überrascht, dass der Python-Interpreter sich aus einem Get-Item,

00:35:49.400 --> 00:35:51.400
aus einem Len, kann er sich alles zusammenbasteln.

00:35:51.400 --> 00:35:54.400
Ich meine, es ist nicht, wenn man so ein bisschen drüber nachdenkt,

00:35:54.400 --> 00:35:57.400
es ist einfach nur smart, dass das geht.

00:35:57.400 --> 00:35:59.400
Und das ist auch klar, dass das geht.

00:35:59.400 --> 00:36:02.400
Wenn ich weiß, wie viele es sind und ich ein einzelnes holen kann,

00:36:02.400 --> 00:36:04.400
dann kann ich auch mehrere holen.

00:36:04.400 --> 00:36:05.400
Okay, gut.

00:36:05.400 --> 00:36:06.400
Ja.

00:36:06.400 --> 00:36:08.400
Und ich kann auch Reverse machen drauf.

00:36:08.400 --> 00:36:10.400
Okay, auch das ist nicht arg überraschend.

00:36:10.400 --> 00:36:12.400
Und ich kann auch Iteration machen drauf.

00:36:12.400 --> 00:36:14.400
Okay, auch das ist nicht arg überraschend mehr.

00:36:14.400 --> 00:36:15.400
Ja.

00:36:15.400 --> 00:36:20.400
Aber dass das implementiert ist, das fand ich sehr cool.

00:36:20.400 --> 00:36:24.400
Ja, man delegiert im Grunde die ganze schlaue

00:36:24.400 --> 00:36:26.400
oder die ganze schwierige Funktionalität von,

00:36:26.400 --> 00:36:29.400
wie das halt so funktioniert, an die interne Liste in der Datenlage.

00:36:29.400 --> 00:36:31.400
Genau, wie das schnell auch funktionieren kann,

00:36:31.400 --> 00:36:33.400
indem man einfach so ein Len-Get-Item definiert.

00:36:33.400 --> 00:36:34.400
Ja, aber ...

00:36:34.400 --> 00:36:36.400
Nee, Jochen ist nicht delegiert.

00:36:36.400 --> 00:36:38.400
Sondern der ruft Len ein Get-Item an.

00:36:38.400 --> 00:36:39.400
Ja, aber das macht er direkt.

00:36:39.400 --> 00:36:41.400
Eine repräsentation von Len wird ja aufgerufen.

00:36:41.400 --> 00:36:44.400
Also das heißt, die Magie, die wirklich dann in C-Python passiert,

00:36:44.400 --> 00:36:46.400
die ja damit schnell ist und so, da muss ich ...

00:36:46.400 --> 00:36:48.400
Okay, also er implementiert ...

00:36:48.400 --> 00:36:51.400
Gut, in dem Beispiel wird nicht implementiert,

00:36:51.400 --> 00:36:53.400
wie du tatsächlich Objekte speicherst,

00:36:53.400 --> 00:36:54.400
sondern benutzt eine Liste.

00:36:54.400 --> 00:36:56.400
Genau, es wird halt sozusagen, das wird weitergereicht,

00:36:56.400 --> 00:36:58.400
die Position wird weitergereicht an die Liste.

00:36:58.400 --> 00:37:00.400
Genau, und die kann halt auch umslicen.

00:37:00.400 --> 00:37:06.400
Also die Implementierung dieser beiden Attribute ist tatsächlich ...

00:37:06.400 --> 00:37:07.400
Also ...

00:37:07.400 --> 00:37:08.400
Ist einfach durchdelegiert.

00:37:08.400 --> 00:37:11.400
Aber dass du dann daraus eine Slicing-Syntax kriegst mit Ranges ...

00:37:11.400 --> 00:37:13.400
Ja, ja, ja, das ist ...

00:37:13.400 --> 00:37:15.400
Das ist ja, das macht ja der Interpreter für dich.

00:37:15.400 --> 00:37:16.400
Ja.

00:37:16.400 --> 00:37:20.400
Also der macht sich diese Ranges und ruft dann die einzelnen Get-Items auf.

00:37:20.400 --> 00:37:21.400
Ja.

00:37:21.400 --> 00:37:22.400
Also hat mich auch gewundert.

00:37:22.400 --> 00:37:26.400
Ich hätte jetzt auch nicht gedacht, dass man dann schon iterieren kann.

00:37:26.400 --> 00:37:27.400
Das war ...

00:37:27.400 --> 00:37:29.400
Genau, das war mir gar nicht klar, dass das reicht,

00:37:29.400 --> 00:37:31.400
Get-Items zu implementieren.

00:37:31.400 --> 00:37:33.400
Also ich muss meine naive Karteninterpretation

00:37:33.400 --> 00:37:35.400
von meinem Kartenspiel, von meinem Pokerspiel auch noch mal anpassen,

00:37:35.400 --> 00:37:37.400
wenn ich das so sehe, weil tatsächlich ich da auch immer

00:37:37.400 --> 00:37:39.400
dann ein Objekt gemacht habe, an dem Karten dran waren,

00:37:39.400 --> 00:37:42.400
was natürlich dann eine Liste war, was aber nicht hieß,

00:37:42.400 --> 00:37:44.400
dass man einfach das Ding mischt,

00:37:44.400 --> 00:37:46.400
sondern man muss halt diese Mischmethode aufrufen.

00:37:46.400 --> 00:37:48.400
Ich glaube, das ist einfach totaler Quatsch.

00:37:48.400 --> 00:37:50.400
Ja, da gibt es aber auch verschiedene Ansätze.

00:37:50.400 --> 00:37:52.400
Da kannst du auch auf verschiedene Arten und Weisen drangehen.

00:37:52.400 --> 00:37:56.400
Du kannst drangehen und sagen, ich mache jetzt eine neue Klasse,

00:37:56.400 --> 00:38:00.400
die eine Liste einpackt und dann halt so ein paar magische Methoden,

00:38:00.400 --> 00:38:02.400
ich sage jetzt ja magische Methoden, exportiert.

00:38:02.400 --> 00:38:07.400
Oder du kannst sagen, ich behandle jetzt eine Liste wie ein X, Y und Z.

00:38:07.400 --> 00:38:11.400
Und dann implementierst du erst mal selber gar nichts,

00:38:11.400 --> 00:38:14.400
sondern benutzt halt die Werkzeuge, die es gibt,

00:38:14.400 --> 00:38:16.400
auf eine bestimmte Art und Weise.

00:38:16.400 --> 00:38:19.400
Es sind ja schon zwei unterschiedliche, aber gleichwertige Herangehensweise.

00:38:19.400 --> 00:38:22.400
Aber dieser letzte Ansatz ist irgendwie smart,

00:38:22.400 --> 00:38:25.400
weil man halt tatsächlich nicht das Rad neu machen muss.

00:38:25.400 --> 00:38:27.400
Und ich glaube, das ist eigentlich sehr personal.

00:38:27.400 --> 00:38:28.400
Der ist ein bisschen impliziter, ja.

00:38:28.400 --> 00:38:30.400
Aber trotzdem sehr personal, sehr sensimplizit ist.

00:38:30.400 --> 00:38:33.400
Und in der Kombination, indem man das halt irgendwie

00:38:33.400 --> 00:38:35.400
schön modellisiert, kann man tolle Sachen machen.

00:38:35.400 --> 00:38:38.400
Also man muss da so ein bisschen ein Boilerplate schreiben vielleicht,

00:38:38.400 --> 00:38:40.400
aber wie man es dann hinterher wirklich benutzt,

00:38:40.400 --> 00:38:44.400
wenn man diese Objekte in der Hand hat, wirkt einfach wie pure Python.

00:38:44.400 --> 00:38:47.400
Weil man halt dann direkt auf dem Deck, was man in der Hand hat,

00:38:47.400 --> 00:38:50.400
in DCs machen kann, Ranges machen kann und so.

00:38:50.400 --> 00:38:52.400
Ja gut, hier geht es ja vor allen Dingen darum,

00:38:52.400 --> 00:38:53.400
diese Methoden zu erklären.

00:38:53.400 --> 00:38:56.400
Insofern, ob man das jetzt so implementieren würde, weiß ich nicht.

00:38:56.400 --> 00:38:59.400
Also keine Ahnung, kommt drauf an, was man damit machen möchte.

00:38:59.400 --> 00:39:03.400
Aber ja, ich finde es auch, es sieht gut aus.

00:39:03.400 --> 00:39:06.400
Kann jetzt keiner sehen, weil es ein Podcast ist leider.

00:39:06.400 --> 00:39:10.400
Kannst du das teilen? Ist das public?

00:39:10.400 --> 00:39:12.400
Ne.

00:39:12.400 --> 00:39:15.400
Oh. Na gut.

00:39:15.400 --> 00:39:18.400
Also ich glaube, es gibt irgendwo bestimmt auf irgendwelchen Kanälen oder so was.

00:39:18.400 --> 00:39:19.400
Ja.

00:39:19.400 --> 00:39:23.400
Das nächste Beispiel, was er bringt, fand ich auch interessant.

00:39:23.400 --> 00:39:26.400
Aber das ist natürlich so ein bisschen dieses Vector-Beispiel.

00:39:26.400 --> 00:39:30.400
Das ist natürlich mehr so ein bisschen, ja.

00:39:30.400 --> 00:39:33.400
Du musst das noch mal verleuchtern bitte, bei allen unserer Hörer*innen,

00:39:33.400 --> 00:39:35.400
was denn das Vector-Beispiel ist.

00:39:35.400 --> 00:39:40.400
Ja, er macht sich eine Klasse, eine zweidimensionale Vector-Klasse.

00:39:40.400 --> 00:39:43.400
Also mit Richtung XY.

00:39:43.400 --> 00:39:46.400
Genau, also ein Koordinatenmodell, ein zweidimensionales Koordinatenmodell.

00:39:46.400 --> 00:39:49.400
Er sagt auch gleich im Vorhinein,

00:39:49.400 --> 00:39:53.400
könntest du auch die Build-In-Klasse Complex verwenden.

00:39:53.400 --> 00:39:56.400
Die kann alles, was wir gleich hier machen und noch viel mehr.

00:39:56.400 --> 00:39:58.400
Aber zum Zeigen ist es ja ganz schön.

00:39:58.400 --> 00:40:02.400
Und da implementiert er drei Special Methods,

00:40:02.400 --> 00:40:05.400
nämlich Add, Abs und Mul.

00:40:05.400 --> 00:40:11.400
Und kriegt daraus dann die Möglichkeit, zwei Vektoren zu addieren.

00:40:11.400 --> 00:40:15.400
Abs wird hier als die Metrik implementiert,

00:40:15.400 --> 00:40:17.400
das heißt, es ist die Länge eines Vektors.

00:40:17.400 --> 00:40:19.400
Und Mul ist eine Skalarmultiplikation,

00:40:19.400 --> 00:40:21.400
das heißt, kannst du einen Vektor mit einem Integer

00:40:21.400 --> 00:40:26.400
oder mit einem Float multiplizieren, kannst du die Länge verändern.

00:40:26.400 --> 00:40:30.400
Auch das mit wenigen Methoden schon relativ viel erreicht

00:40:30.400 --> 00:40:32.400
und auch relativ viel Syntax erreicht.

00:40:32.400 --> 00:40:35.400
Das fehlt aber noch mit Vektor multiplizieren.

00:40:35.400 --> 00:40:38.400
Ja, das ist nicht so einfach, dummerweise.

00:40:38.400 --> 00:40:40.400
Das ist mathematisch nicht so einfach.

00:40:40.400 --> 00:40:43.400
Genau, da steht, glaube ich, im Buch irgendwas drin.

00:40:43.400 --> 00:40:45.400
Ja, also wie man das dann macht mit Magic Method,

00:40:45.400 --> 00:40:48.400
das ist dann Kapitel 16 oder so viel weiter hinten.

00:40:48.400 --> 00:40:50.400
Das ist nicht so einfach.

00:40:50.400 --> 00:40:52.400
Und er sagt auch, er verschiebt auch,

00:40:52.400 --> 00:40:54.400
das tatsächlich in diesen ersten Kapiteln

00:40:54.400 --> 00:40:56.400
verschiebt er relativ viel auch später.

00:40:56.400 --> 00:40:58.400
Ja, hier, das kommt in Kapitel 17 noch mal

00:40:58.400 --> 00:41:01.400
oder Kapitel 38 oder Kapitel 12.

00:41:01.400 --> 00:41:05.400
Tatsächlich auch Skalar mit Vektor multiplizieren,

00:41:05.400 --> 00:41:09.400
also eine Zahl mal Vektor verschiebt er auch auch später,

00:41:09.400 --> 00:41:12.400
weil da brauchst du nochmal eine andere Special Method,

00:41:12.400 --> 00:41:16.400
weil eben Mul nur Vektor mit Skalar kann.

00:41:16.400 --> 00:41:19.400
Und das ist dann so ein kleines bisschen unbefriedigend.

00:41:19.400 --> 00:41:22.400
Was ich aber eigentlich, worauf ich eigentlich raus wollte, ist,

00:41:22.400 --> 00:41:25.400
er hat halt dann die Möglichkeit, seine Klasse mit Plus,

00:41:25.400 --> 00:41:27.400
hat er zwei Vektoren, zwei Instanzen von seiner Klasse,

00:41:27.400 --> 00:41:29.400
kann er mit Plus addieren.

00:41:29.400 --> 00:41:32.400
Und das fand ich nicht so beeindruckend,

00:41:32.400 --> 00:41:35.400
weil das gab es in C++ auch schon.

00:41:35.400 --> 00:41:38.400
Das musste ich auch schon mal lernen.

00:41:38.400 --> 00:41:40.400
Und da heißen die Methoden halt anders,

00:41:40.400 --> 00:41:42.400
da heißen sie Operator Plus und Operator Minus

00:41:42.400 --> 00:41:44.400
und Operator noch irgendwas.

00:41:44.400 --> 00:41:46.400
Und dann kriegst du es aber auch,

00:41:46.400 --> 00:41:48.400
kannst auch Vektoren addieren und so weiter.

00:41:48.400 --> 00:41:51.400
Deshalb, da war ich jetzt nicht so beeindruckt davon.

00:41:51.400 --> 00:41:53.400
Ja.

00:41:53.400 --> 00:41:55.400
Ich habe das mit dem Multiplizieren nicht verstanden,

00:41:55.400 --> 00:41:57.400
was du meintest mit Skalar mal Vektor und Vektor mal Skalar,

00:41:57.400 --> 00:41:59.400
wo ist denn der Unterschied, dass das nicht komutativ ist?

00:41:59.400 --> 00:42:01.400
Das ist die Reihenfolge.

00:42:01.400 --> 00:42:03.400
Du kannst halt nicht ...

00:42:03.400 --> 00:42:05.400
Eigentlich mathematisch gesehen ist diese Operation komutativ,

00:42:05.400 --> 00:42:08.400
aber in Python, an dieser Stelle ist sie noch nicht komutativ,

00:42:08.400 --> 00:42:12.400
weil wenn du die Mul-Methode implementierst,

00:42:12.400 --> 00:42:15.400
auf einem, auf deiner Klasse,

00:42:15.400 --> 00:42:19.400
dann musst, wenn du x mal y machst,

00:42:19.400 --> 00:42:21.400
dann wird x Punkt Mul aufgerufen.

00:42:21.400 --> 00:42:24.400
Weil ansonsten wird dann tatsächlich, ja, genau,

00:42:24.400 --> 00:42:26.400
ansonsten von dem Skalar die Mul-Methode aufgerufen,

00:42:26.400 --> 00:42:28.400
da gibt es den Vektor nicht.

00:42:28.400 --> 00:42:30.400
Genau, und die kann natürlich nicht mit Vektoren umgehen.

00:42:30.400 --> 00:42:32.400
Und damit es in die andere Richtung geht,

00:42:32.400 --> 00:42:34.400
brauchst du eine zweite Special Method,

00:42:34.400 --> 00:42:36.400
da heißt R-Mul, also Reverse Multiplication.

00:42:36.400 --> 00:42:38.400
Und die hat er aber auch später verschoben,

00:42:38.400 --> 00:42:40.400
weil die später noch mal kommt.

00:42:40.400 --> 00:42:42.400
Ach, man kann auch R-Mul, interessant, das wusste ich auch nicht.

00:42:42.400 --> 00:42:44.400
Genau, damit eben diese Komutativität.

00:42:44.400 --> 00:42:46.400
Aber es wird zuerst Mul aufgerufen,

00:42:46.400 --> 00:42:49.400
das heißt, da geht es dann auch noch um Präzedenz,

00:42:49.400 --> 00:42:52.400
und deshalb verschiebt er das, glaube ich, auch später.

00:42:52.400 --> 00:42:54.400
Wie kriegt man denn die Präzedenz hin?

00:42:54.400 --> 00:42:57.400
Also ich möchte das gerne spoilern, bitte.

00:42:57.400 --> 00:42:59.400
Die kriegst du hin, also,

00:42:59.400 --> 00:43:02.400
ist in dem Fall jetzt hier tatsächlich unproblematisch,

00:43:02.400 --> 00:43:04.400
aber du musst dann natürlich Typechecks machen,

00:43:04.400 --> 00:43:06.400
dass du sagst, okay, was ist denn, wenn ich ein R-Mul mach

00:43:06.400 --> 00:43:09.400
mit dieser oder jener Sorte von Objekt?

00:43:09.400 --> 00:43:11.400
Weil da kann ja dann prinzipiell alles rein.

00:43:11.400 --> 00:43:13.400
Alles, ja.

00:43:13.400 --> 00:43:16.400
Matchcase mit Typechecks.

00:43:16.400 --> 00:43:18.400
Ja, so mit einem Matchcase oder mit einem ...

00:43:18.400 --> 00:43:20.400
Alles, was du nicht implementiert hast,

00:43:20.400 --> 00:43:22.400
wird einfach im Normalkreis abgehandelt,

00:43:22.400 --> 00:43:24.400
und ansonsten schreibst du für alle Caches,

00:43:24.400 --> 00:43:27.400
die einmal auftauchen, was rein.

00:43:27.400 --> 00:43:29.400
Find ich gut.

00:43:29.400 --> 00:43:31.400
Im Endeffekt macht der Interpreter das ja auch so, ja.

00:43:31.400 --> 00:43:34.400
Also wenn eine von diesen Methoden halt einen Fehler wirft

00:43:34.400 --> 00:43:36.400
oder kein Ergebnis zurückgibt,

00:43:36.400 --> 00:43:39.400
dann wird halt so lange weitere Methoden durchprobiert,

00:43:39.400 --> 00:43:41.400
bis es eins gibt, und wenn es keinen gibt,

00:43:41.400 --> 00:43:44.400
dann sagt er halt, das ist nicht definiert für diese Typen.

00:43:44.400 --> 00:43:46.400
Das haben wir ja auch alle schon mal gesehen, oder?

00:43:46.400 --> 00:43:48.400
Dass man versedelich einen String zu einer Zahl addiert hat

00:43:48.400 --> 00:43:50.400
und dann gesagt bekommen hat, das kannst du nicht.

00:43:50.400 --> 00:43:52.400
Es sei denn, man war in JavaScript.

00:43:52.400 --> 00:43:56.400
Ja, ja, das ist halt so ein fundamentaler Unterschied

00:43:56.400 --> 00:43:58.400
zwischen JavaScript und Python.

00:43:58.400 --> 00:44:03.400
Ja, genau.

00:44:03.400 --> 00:44:05.400
Ich finde das ja auch sehr ...

00:44:05.400 --> 00:44:07.400
Ich weiß nicht, haben wir überhaupt schon definiert?

00:44:07.400 --> 00:44:09.400
Mir fällt das gerade so heiß ein,

00:44:09.400 --> 00:44:11.400
jetzt reden wir schon die ganze Zeit drüber,

00:44:11.400 --> 00:44:13.400
aber ich weiß nicht, haben wir überhaupt gesagt,

00:44:13.400 --> 00:44:15.400
wie diese Dunder Methods denn aussehen?

00:44:15.400 --> 00:44:18.400
Also wir haben immer irgendwie zwei Underscores,

00:44:18.400 --> 00:44:21.400
damit fangen sie mal an, und hören immer mit zwei Underscores auf.

00:44:21.400 --> 00:44:24.400
Genau, Dunder, für alle Leute, die es nicht kennen, das Unterstrich.

00:44:24.400 --> 00:44:28.400
Dunder ist halt quasi die Abkürzung für Double Underscore Before

00:44:28.400 --> 00:44:30.400
and Double Underscore After.

00:44:30.400 --> 00:44:32.400
Warum haben wir Underscores damit?

00:44:32.400 --> 00:44:34.400
Man denkt, die gibt es gar nicht, damit man die nicht sieht,

00:44:34.400 --> 00:44:37.400
damit die nicht auffallen.

00:44:37.400 --> 00:44:39.400
Nö, Konvention.

00:44:39.400 --> 00:44:40.400
Keine Ahnung.

00:44:40.400 --> 00:44:42.400
Wie du so unterscheiden kannst von allen anderen.

00:44:42.400 --> 00:44:44.400
Das ist eine Konvention im Python-Interpreter,

00:44:44.400 --> 00:44:46.400
wenn du eine Methode hast, die zwei Unterstriche vorne

00:44:46.400 --> 00:44:48.400
und zwei Unterstriche hinten hat,

00:44:48.400 --> 00:44:50.400
dann verspricht der Interpreter gar nichts darüber.

00:44:50.400 --> 00:44:52.400
Das kann sich jederzeit ändern,

00:44:52.400 --> 00:44:55.400
und es kann jederzeit passieren, dass die nicht mehr funktioniert.

00:44:55.400 --> 00:44:57.400
Ist einfach nur eine visuelle Abtrennung,

00:44:57.400 --> 00:44:59.400
dass du siehst, dass das was Spezielles ist.

00:44:59.400 --> 00:45:01.400
Aber wenn ich das richtig verstehe,

00:45:01.400 --> 00:45:03.400
ruft man solche Methoden niemals selber einfach so an?

00:45:03.400 --> 00:45:05.400
Nein, niemals stimmt nicht so ganz.

00:45:05.400 --> 00:45:07.400
Also ab und zu schon.

00:45:07.400 --> 00:45:09.400
Eine ganz populäre ist, achso, das wolltest du auch gerade sagen,

00:45:09.400 --> 00:45:10.400
ist halt ...

00:45:10.400 --> 00:45:12.400
Ich tu ja, DunderInit.

00:45:12.400 --> 00:45:15.400
Dann ruft man den Init explizit auf von außen.

00:45:15.400 --> 00:45:16.400
Ständig.

00:45:16.400 --> 00:45:17.400
Nur mit Super.

00:45:17.400 --> 00:45:18.400
Nee, ständig.

00:45:18.400 --> 00:45:19.400
Ja.

00:45:19.400 --> 00:45:21.400
Wenn du halt Klasse, Klammer auf, Klammer zu,

00:45:21.400 --> 00:45:23.400
dann hast du schon aufgerufen.

00:45:23.400 --> 00:45:25.400
Das ist ja die implizite.

00:45:25.400 --> 00:45:28.400
Ich meine, dass du explizit jetzt dran schreibst Init.

00:45:28.400 --> 00:45:31.400
Ja, okay, das passiert tatsächlich nicht so häufig.

00:45:31.400 --> 00:45:33.400
Ja, bei Super aufrufen schon.

00:45:33.400 --> 00:45:35.400
Ja gut, aber das ist ja eine super Analyse.

00:45:35.400 --> 00:45:37.400
Absolut im anderen Init.

00:45:37.400 --> 00:45:39.400
Und das offensichtlich.

00:45:39.400 --> 00:45:42.400
Einen Sturmfile kenne ich jetzt eigentlich keinen.

00:45:42.400 --> 00:45:44.400
Also sei denn, man will irgendwas debuggen oder so,

00:45:44.400 --> 00:45:46.400
dann machen wir alles anders.

00:45:46.400 --> 00:45:48.400
Es ist halt auch nicht notwendig.

00:45:48.400 --> 00:45:50.400
Das ist ja der Trick da dran.

00:45:50.400 --> 00:45:52.400
Du brauchst die nicht direkt aufrufen,

00:45:52.400 --> 00:45:54.400
weil es gibt da Syntax-Sachen.

00:45:54.400 --> 00:45:56.400
Wenn ich jetzt ein App definiere, dann mache ich einfach ein String,

00:45:56.400 --> 00:45:58.400
dann kriege ich das Ergebnis.

00:45:58.400 --> 00:46:00.400
Und wenn ich ein Apps definiere,

00:46:00.400 --> 00:46:02.400
dann möchte ich halt irgendwie mit den Dingen rechnen

00:46:02.400 --> 00:46:04.400
und gucken, was passiert.

00:46:04.400 --> 00:46:06.400
Oder beim Bool vergleiche ich mit irgendwas oder so.

00:46:06.400 --> 00:46:08.400
Oder ich mache ein If vor.

00:46:08.400 --> 00:46:10.400
Das sind halt so Dinge, die eine gute Interventierung sind,

00:46:10.400 --> 00:46:12.400
um mit normaler Python-Syntax und den Objekten zu interagieren.

00:46:12.400 --> 00:46:14.400
Also zum Beispiel Equals oder so.

00:46:14.400 --> 00:46:16.400
Oder Lesser than.

00:46:16.400 --> 00:46:18.400
Oder ein komparatives Verhalten zwischen einzelnen Objekten

00:46:18.400 --> 00:46:20.400
von Klassen oder von Instanzen.

00:46:20.400 --> 00:46:22.400
Ja, du kannst halt sozusagen mit dem Interpreter so interagieren,

00:46:22.400 --> 00:46:24.400
wie die anderen Teile in Python halt auch.

00:46:24.400 --> 00:46:26.400
Und das ist halt eine Besonderheit von Python.

00:46:26.400 --> 00:46:28.400
Das geht in vielen anderen Sprachen nicht.

00:46:28.400 --> 00:46:30.400
Genau, das macht es halt toll.

00:46:30.400 --> 00:46:32.400
Das ist halt genau das Schöne an diesen Magic Methods ist,

00:46:32.400 --> 00:46:34.400
dass wenn man das ordentlich interventiert,

00:46:34.400 --> 00:46:36.400
man hinterher, wenn man das nicht so gut kennt,

00:46:36.400 --> 00:46:38.400
wenn man das ordentlich interventiert,

00:46:38.400 --> 00:46:40.400
man hinterher in seinem Code Sachen machen kann,

00:46:40.400 --> 00:46:42.400
die sehr natürlich aussehen.

00:46:42.400 --> 00:46:44.400
Und die auch in der logischen Sprache dann natürlich Sinn machen,

00:46:44.400 --> 00:46:46.400
wenn man Dinge miteinander vergleichen möchte,

00:46:46.400 --> 00:46:48.400
die man dann vielleicht auch vergleichen kann,

00:46:48.400 --> 00:46:50.400
weil man den ordentlichen Namen gegeben hat.

00:46:50.400 --> 00:46:52.400
Und das aber einfach mit den instanzierten Objekten geht.

00:46:52.400 --> 00:46:54.400
Und man halt nicht irgendwie komische Dundern-Methoden

00:46:54.400 --> 00:46:56.400
oder irgendwelche kryptischen Namen an Objekten aufrufen muss,

00:46:56.400 --> 00:46:58.400
wie das in anderen Sprachen der Fall ist.

00:46:58.400 --> 00:47:00.400
Und das ist toll, weil dieser Syntax-Sugar Magie macht.

00:47:00.400 --> 00:47:02.400
Und deswegen finde ich den Namen Magic Methods auch sehr schön.

00:47:02.400 --> 00:47:04.400
Ja, das ist auch eine tolle Idee.

00:47:04.400 --> 00:47:06.400
Ich finde den Namen Magic Methods auch sehr schön.

00:47:06.400 --> 00:47:12.400
Ja, du kriegst also Zugriff auf die Innereien des Python-Integrators.

00:47:12.400 --> 00:47:15.400
Und du kannst dich da genauso rein integrieren wie alle,

00:47:15.400 --> 00:47:18.400
als ob du dazugehörst. Und das ist schon was sehr Schönes.

00:47:18.400 --> 00:47:20.400
Aber du hast eben noch was anderes gesagt, Dominik,

00:47:20.400 --> 00:47:22.400
was auch hier vorkommt, was ich auch in meinen Notizen habe.

00:47:22.400 --> 00:47:25.400
Du hast gesagt, du möchtest hier die String-Methode implementieren.

00:47:25.400 --> 00:47:27.400
Und dann kriegst du eine schöne String-Repräsentation raus.

00:47:27.400 --> 00:47:29.400
Welche Reprä-Methode?

00:47:29.400 --> 00:47:31.400
Ink.

00:47:31.400 --> 00:47:34.400
Oh, dann muss ich noch mal zurückscrollen und mir das anhören.

00:47:34.400 --> 00:47:37.400
Aber das ist tatsächlich was, ich tendiere auch dazu,

00:47:37.400 --> 00:47:39.400
immer die String-Methode zu implementieren,

00:47:39.400 --> 00:47:41.400
weil man das halt so gewöhnt ist.

00:47:41.400 --> 00:47:44.400
Bei Java machst du Two-String, bei irgendwelchen anderen

00:47:44.400 --> 00:47:48.400
machst du irgendeine Two-String-Transformation oder was auch immer.

00:47:48.400 --> 00:47:50.400
Und in Python gibt es da ja zwei davon.

00:47:50.400 --> 00:47:52.400
Es gibt Repre und String.

00:47:52.400 --> 00:47:54.400
Genau.

00:47:54.400 --> 00:47:59.400
Und der Unterschied ist schwer zu erklären,

00:47:59.400 --> 00:48:03.400
weil er nicht so was Formales ist.

00:48:03.400 --> 00:48:05.400
Ich versuch's trotzdem mal.

00:48:05.400 --> 00:48:08.400
Die Repräsentation ist das, was in der Kommandozeile auftaucht,

00:48:08.400 --> 00:48:10.400
oder einem String, wenn du ihn da reingeschrieben hast.

00:48:10.400 --> 00:48:14.400
Und String ist das, was rauskommt, wenn du die String-Conversion versuchst.

00:48:14.400 --> 00:48:18.400
Ja, aber warum macht man da überhaupt einen Unterschied?

00:48:18.400 --> 00:48:20.400
Warum braucht es da zwei?

00:48:20.400 --> 00:48:22.400
Könntest du da genau einen Einheimischen machen?

00:48:22.400 --> 00:48:24.400
Das identifiziert das Objekt?

00:48:24.400 --> 00:48:26.400
Okay, erklär du, Johannes.

00:48:27.400 --> 00:48:31.400
Nee, also das geht schon so ein bisschen runter auf die Krux des Problems,

00:48:31.400 --> 00:48:34.400
weil diese zwei Methoden doch relativ ähnlich sind.

00:48:34.400 --> 00:48:37.400
Aber interessanterweise, wenn du den String nicht implementiert hast,

00:48:37.400 --> 00:48:40.400
fällt der zurück auf Rep, also auf die Repräsentation.

00:48:40.400 --> 00:48:44.400
Und die Repräsentation ist in dem Sinne ein bisschen formaler,

00:48:44.400 --> 00:48:47.400
weil das heißt, du sollst eine Repräsentation wählen,

00:48:47.400 --> 00:48:52.400
die du idealerweise direkt in den Interpreter rein kopieren kannst.

00:48:54.400 --> 00:48:56.400
Und das schränkt dich natürlich relativ ein.

00:48:56.400 --> 00:49:00.400
Das heißt, da hast du üblicherweise dann so was wie eben einen Konstruktor

00:49:00.400 --> 00:49:03.400
da drin stehen oder eine String-Repräsentation des Konstruktors.

00:49:03.400 --> 00:49:07.400
Die String-Methode soll einfach nur eine menschenlesbare Beschreibung

00:49:07.400 --> 00:49:08.400
dieses Objektes sein.

00:49:08.400 --> 00:49:10.400
Und die kann dann natürlich auch was anderes sein.

00:49:10.400 --> 00:49:13.400
Also zum Beispiel für diese Vektor-Klasse,

00:49:13.400 --> 00:49:17.400
da hat er als Representation halt den Namen der Klasse, Vektor 2,

00:49:17.400 --> 00:49:21.400
Klammer auf, dann die beiden Koordinaten und dann Klammer zu.

00:49:21.400 --> 00:49:25.400
Und das ist gut, weil das kannst du direkt rein kopieren,

00:49:25.400 --> 00:49:27.400
das identifiziert genau diese Sache.

00:49:27.400 --> 00:49:31.400
Als String-Methode, hat er jetzt hier kein Beispiel im Buch drin,

00:49:31.400 --> 00:49:34.400
würde ich aber tatsächlich was anderes wählen.

00:49:34.400 --> 00:49:40.400
Ich würde entweder je nach Kontext vielleicht eckige Klammern wählen

00:49:40.400 --> 00:49:43.400
oder in einem mathematischen Kontext vielleicht sogar runde Klammern.

00:49:43.400 --> 00:49:46.400
Genau, spitze Klammern, Entschuldigung.

00:49:46.400 --> 00:49:49.400
Oder vielleicht sogar runde, je nachdem, welchen Kontext es hat.

00:49:49.400 --> 00:49:51.400
Und da hat man natürlich einfach mehr Freiheit,

00:49:51.400 --> 00:49:57.400
weil das einfach eine menschenlesbare Darstellung dieses Objektes sein soll.

00:49:57.400 --> 00:50:03.400
Und ich tendiere eher dazu, die String-Methode zu implementieren

00:50:03.400 --> 00:50:08.400
und die Argumente, die hier der Luciano uns gibt,

00:50:08.400 --> 00:50:14.400
die lassen mich jetzt doch auch tendieren dazu eher Rapper zu sein.

00:50:14.400 --> 00:50:17.400
Also das ist sozusagen die Regel, die man da mitnehmen kann,

00:50:17.400 --> 00:50:21.400
ist halt, wenn man sich entscheiden muss,

00:50:21.400 --> 00:50:24.400
dann lieber eher nur die Rapper-Methode implementieren,

00:50:24.400 --> 00:50:26.400
nicht unbedingt das andere.

00:50:26.400 --> 00:50:30.400
Und das war mir auch nicht so in der Feinheit klar,

00:50:30.400 --> 00:50:33.400
was jetzt da der genaue Unterschied oder der Sinn dahinter ist.

00:50:33.400 --> 00:50:36.400
Und das weiß ich jetzt voll gut, weiß ich schon wieder mehr.

00:50:36.400 --> 00:50:38.400
Ja, das ist voll gut, oder?

00:50:38.400 --> 00:50:40.400
Ja, ja, ja.

00:50:40.400 --> 00:50:44.400
Ich war etwas überrascht, als ich das Buch angefangen habe,

00:50:44.400 --> 00:50:47.400
weil das erste Kapitel schon ordentlich rangeht.

00:50:47.400 --> 00:50:49.400
Ein Fängerbuch, hat Jochen gesagt.

00:50:49.400 --> 00:50:54.400
Nein, das ist auf jeden Fall ein fortgeschrittenes Buch.

00:50:54.400 --> 00:50:58.400
Und der macht auch keine Pausen, der geht direkt weiter hier.

00:50:58.400 --> 00:51:02.400
Zwei Klassen mit Operatoren, also das ist diese Deck-Klasse

00:51:02.400 --> 00:51:06.400
und die Vector-Klasse, und dann macht er noch Bool-Implementierung

00:51:06.400 --> 00:51:09.400
und dann geht es gleich mit der Collection-API weiter.

00:51:09.400 --> 00:51:13.400
Auch das, sehr interessant, sehr interessanter Abschnitt

00:51:13.400 --> 00:51:17.400
über die Collection-API, wo natürlich jetzt mehr an Details drin ist,

00:51:17.400 --> 00:51:21.400
die ich weder präsent hatte, noch jetzt so präsent habe.

00:51:21.400 --> 00:51:25.400
Ja, also jetzt muss man es trotzdem mal kurz einmal vorlesen, bitte.

00:51:25.400 --> 00:51:28.400
Ja, dafür ist das Buch halt, also das Buch ist schon dicht,

00:51:28.400 --> 00:51:31.400
okay, ich gebe es zu, aber dafür ist es halt auch nicht so lang.

00:51:31.400 --> 00:51:33.400
Ja, das stimmt.

00:51:33.400 --> 00:51:35.400
Die nächste Lüge, Jochen.

00:51:35.400 --> 00:51:37.400
975 Seiten.

00:51:37.400 --> 00:51:41.400
Aber es ist ein Taschenbuch-Format, also kann man locker

00:51:41.400 --> 00:51:44.400
auch in die Tasche stecken, ist auch relativ klein.

00:51:44.400 --> 00:51:48.400
961, also vielleicht 18 mal 20 Zentimeter.

00:51:48.400 --> 00:51:50.400
Ja, also das ist auf jeden Fall doch die Größe,

00:51:50.400 --> 00:51:52.400
die man sich locker unter das Kopfkissen legen kann.

00:51:52.400 --> 00:51:54.400
Damit es sich von automatisch lernt, ja.

00:51:54.400 --> 00:51:58.400
Kannst du dein Kopfkissen ersetzen, kannst du das mit dem Buch.

00:51:58.400 --> 00:52:05.400
Ja, aber tatsächlich, also diese, da ist sogar ein UML-Diagramm,

00:52:05.400 --> 00:52:08.400
das muss ich sagen, weil ich so fast ein bisschen geschreckt bin.

00:52:08.400 --> 00:52:09.400
Oh, jetzt traufe ich es auch.

00:52:09.400 --> 00:52:11.400
UML-Diagramm, oh Gott, oh Gott, oh Gott.

00:52:11.400 --> 00:52:15.400
Aber ja, an der Stelle macht es tatsächlich Sinn.

00:52:15.400 --> 00:52:17.400
Ja, genau.

00:52:17.400 --> 00:52:20.400
Dominik und ich, wir blättern jetzt gerade für die Zuhörer.

00:52:20.400 --> 00:52:26.400
Ja, genau, da gibt es halt ein UML-Diagramm von der Collection API.

00:52:26.400 --> 00:52:28.400
Und was ist jetzt die Collection API?

00:52:28.400 --> 00:52:31.400
Ich habe es immer noch nicht genau verstanden, bitte wiederhol das doch nochmal.

00:52:31.400 --> 00:52:33.400
Ja, also die ist sozusagen.

00:52:33.400 --> 00:52:35.400
Was ist überhaupt eine Collection?

00:52:35.400 --> 00:52:37.400
Um was geht es da?

00:52:37.400 --> 00:52:38.400
Meta-Tools oder?

00:52:38.400 --> 00:52:47.400
Ne, da geht es darum, wie grundsätzlich quasi Objekte in Python irgendwie so funktionieren,

00:52:47.400 --> 00:52:49.400
die eine Collection von irgendwas sind.

00:52:49.400 --> 00:52:51.400
Und das sind halt die allermeisten, ja.

00:52:51.400 --> 00:52:53.400
Das sieht jetzt hier nicht so aus, sieht nach irgendwas Speziellem aus,

00:52:53.400 --> 00:52:56.400
aber das sind halt die allerallermeisten sind da so was.

00:52:56.400 --> 00:53:00.400
Und da gibt es also Collection selber.

00:53:00.400 --> 00:53:04.400
Man hört es zwar klicken, Jochen, aber.

00:53:04.400 --> 00:53:11.400
Also damit es eine ist, müssen drei Sachen irgendwie implementiert sein.

00:53:11.400 --> 00:53:16.400
Also es gibt halt drei Methoden, die sozusagen dann ein Ding zu einer Collection machen.

00:53:16.400 --> 00:53:18.400
Und das ist halt.

00:53:18.400 --> 00:53:19.400
Iter?

00:53:19.400 --> 00:53:21.400
Iter, ja, du kannst halt irgendwie drüber iterieren.

00:53:21.400 --> 00:53:25.400
Also einen Iterator bauen, einen Generator, der irgendwas yieldet.

00:53:25.400 --> 00:53:26.400
Ne.

00:53:26.400 --> 00:53:27.400
Nein.

00:53:27.400 --> 00:53:29.400
Du kannst, es muss halt irgendwie.

00:53:29.400 --> 00:53:30.400
Fast.

00:53:30.400 --> 00:53:35.400
Mal ganz generell, so eine Collection ist einfach eine Sammlung von anderen Sachen.

00:53:35.400 --> 00:53:36.400
Ja.

00:53:36.400 --> 00:53:38.400
Eine Sammlung von anderen Dingen.

00:53:38.400 --> 00:53:43.400
Und um das zu ermöglichen, gibt es jetzt hier diese verschiedenen Interfaces, die der Jochen jetzt gerade auszeigt.

00:53:43.400 --> 00:53:45.400
Okay, also erst mal, es muss eine iterable sein, ja und dann?

00:53:45.400 --> 00:53:46.400
Ja, es muss irgendwie.

00:53:46.400 --> 00:53:47.400
Muss nicht, aber kann.

00:53:47.400 --> 00:53:49.400
Doch, muss eigentlich.

00:53:49.400 --> 00:53:52.400
Also eine Collection, okay, eine Collection muss das schon sein.

00:53:52.400 --> 00:53:55.400
Aber es kann ja, es kann etwas geben, was iterable ist, aber keine Collection ist.

00:53:55.400 --> 00:53:56.400
Ja, klar, genau.

00:53:56.400 --> 00:53:57.400
Das gibt es natürlich.

00:53:57.400 --> 00:54:00.400
Aber eine Collection muss iterable sein und das ist irgendwas, was yieldet.

00:54:00.400 --> 00:54:13.400
Ja, sie muss halt iterable sein, also sie muss halt irgendwie eine Größe haben, sie muss halt size sein und sie muss halt irgendwie ein Container sein, in dem man halt fragen kann, ja, ist das denn in dir drin oder nicht?

00:54:13.400 --> 00:54:18.400
Und das sind die drei Dinge, die man halt quasi implementiert haben muss, damit man irgendwie eine Collection ist.

00:54:18.400 --> 00:54:20.400
Also ist this a part of your collection?

00:54:20.400 --> 00:54:22.400
Wie viel wirst du denn?

00:54:22.400 --> 00:54:26.400
Und gib mal mehr von dir, von allem, was in dir drin ist.

00:54:26.400 --> 00:54:30.400
Das heißt, wenn ich über alles iteriere, dann habe ich alles drin, was drin war, alles Toys.

00:54:30.400 --> 00:54:34.400
For everything in collection, iterable?

00:54:34.400 --> 00:54:35.400
Ist das so, Jochen?

00:54:35.400 --> 00:54:37.400
Ja, müssen iterate über alle?

00:54:37.400 --> 00:54:39.400
Nee, ich denke nicht, ich denke nicht.

00:54:39.400 --> 00:54:43.400
Also du kannst ja dann in der, wenn du das implementierst, da drin ja machen, was du willst.

00:54:43.400 --> 00:54:47.400
Das kann jetzt auch von irgendwas anderem abhängig sein, was das zugegeben hat.

00:54:47.400 --> 00:54:49.400
Es muss nur das Iter-Protokoll erfüllen.

00:54:49.400 --> 00:54:50.400
Ja, genau, es muss nur das Protokoll erfüllen.

00:54:50.400 --> 00:54:52.400
Es muss nur mal eins, ein nächstes rausgeben.

00:54:52.400 --> 00:54:55.400
Also immer dasselbe, wie das mit der Pathologischen Edge Case ist.

00:54:55.400 --> 00:54:56.400
Gib mir mal alle deine Dinge.

00:54:56.400 --> 00:54:57.400
Ich will das erste, nee, du kriegst das erste.

00:54:57.400 --> 00:54:58.400
Du kriegst doch das erste.

00:54:58.400 --> 00:55:00.400
Nein, das und das erste, immer das erste.

00:55:00.400 --> 00:55:05.400
Nee, nee, du rufst ja, das Iter-Protokoll ist ja, du rufst immer Next auf, auf dem Iterable-Protokoll.

00:55:05.400 --> 00:55:06.400
Ach, das ist doch ein geiler Passwort.

00:55:06.400 --> 00:55:07.400
Das heißt, du kriegst immer ein nächstes Element.

00:55:07.400 --> 00:55:09.400
Aber das bedeutet nicht, dass du alle kriegst.

00:55:09.400 --> 00:55:11.400
Und das bedeutet auch nicht, dass du alle kriegen kannst.

00:55:11.400 --> 00:55:15.400
Es gibt ja diese Pathologischen Edge Cases, die man immer in Einführungsveranstaltungen macht,

00:55:15.400 --> 00:55:18.400
dass man sagt, hier, wir machen jetzt jetzt mal was Iterable.

00:55:18.400 --> 00:55:20.400
Und das berechnet einfach die nächste Primzahl.

00:55:20.400 --> 00:55:21.400
Es gibt ja alle Primzahlen.

00:55:21.400 --> 00:55:24.400
Aber das ist natürlich keine Sammlung, die je aufhört.

00:55:24.400 --> 00:55:25.400
Was ist denn der Unterschied?

00:55:25.400 --> 00:55:26.400
Über alle Primzahlen, die drin.

00:55:26.400 --> 00:55:28.400
Unterschied, Joachim?

00:55:28.400 --> 00:55:31.400
Mit dem Generator und dem Next und dem Yield und dem ...

00:55:31.400 --> 00:55:34.400
Naja, also Iter ist halt die grundsätzliche Geschichte.

00:55:34.400 --> 00:55:38.400
Das ist halt das, was du brauchst, wenn du ein Vor-Irgendwas in Irgendwas sagst.

00:55:38.400 --> 00:55:42.400
Ja, ein Generator ist eine Spezifikation, das ist halt nicht so allgemein.

00:55:42.400 --> 00:55:49.400
So ein Generator heißt halt dann, sozusagen da, ja, kriegst du halt eins nach dem anderen Ding.

00:55:49.400 --> 00:55:53.400
Also wenn ich jetzt irgendwas iteriere, ist das was anderes als ein eins nach dem anderen?

00:55:53.400 --> 00:55:59.400
Also sagen wir mal so, Generator ist nochmal eine speziellere Geschichte.

00:55:59.400 --> 00:56:04.400
Das ist jetzt nicht das Gleiche, wie was du integrieren kannst.

00:56:04.400 --> 00:56:05.400
Das ist was anderes.

00:56:05.400 --> 00:56:07.400
Ein Generator implementiert, ja.

00:56:07.400 --> 00:56:10.400
Ein Generator implementiert das Iterable-Protokoll.

00:56:10.400 --> 00:56:13.400
Also ist schon Iterable, ein Generator.

00:56:13.400 --> 00:56:15.400
Aber es ist eine sehr spezielle Art von was, Iterable.

00:56:15.400 --> 00:56:17.400
Aha, okay.

00:56:17.400 --> 00:56:22.400
Aber eine Liste ist auch irgendwie was Iterable ist, aber das ist kein Generator, gar nicht.

00:56:22.400 --> 00:56:23.400
Nein?

00:56:23.400 --> 00:56:24.400
Nein.

00:56:24.400 --> 00:56:25.400
Das Comprehension schon.

00:56:25.400 --> 00:56:28.400
Also wenn du eine List Comprehension schreibst, kriegst du eine Liste zurück.

00:56:28.400 --> 00:56:31.400
Du kannst den Generator Expression hinschreiben, dann kriegst du einen Generator.

00:56:31.400 --> 00:56:32.400
Aber das ist wieder was anderes.

00:56:32.400 --> 00:56:34.400
Also, ja.

00:56:34.400 --> 00:56:38.400
Aber interessant finde ich halt, dass das halt reicht.

00:56:38.400 --> 00:56:44.400
Also diese drei Dinge, also wenn du die Dynamethods Iter, Len und Contains implementierst,

00:56:44.400 --> 00:56:47.400
dann hast du halt ein Collection quasi.

00:56:47.400 --> 00:56:50.400
Und dann gibt es halt noch die eine zusätzliche Geschichte,

00:56:50.400 --> 00:56:55.400
die halt sozusagen dann daraus etwas, nochmal was Besonderes macht.

00:56:55.400 --> 00:56:58.400
Das ist halt Reversible.

00:56:58.400 --> 00:57:03.400
Wenn das irgendeine Reihenfolge hat, dann ist es halt eine Sequence.

00:57:03.400 --> 00:57:05.400
Ja, aber das ist halt das, was das unterscheidet.

00:57:05.400 --> 00:57:08.400
Also eine Sequence kann halt irgendwie beliebig sortiert werden.

00:57:08.400 --> 00:57:10.400
So, das macht es halt so besonders.

00:57:10.400 --> 00:57:12.400
Und das klassische Beispiel ist eine Liste.

00:57:12.400 --> 00:57:15.400
Wenn man Sequence sagt, kann man immer an eine Liste denken.

00:57:15.400 --> 00:57:16.400
Ja.

00:57:16.400 --> 00:57:22.400
Und genau, ansonsten ist halt ein Tickt, ist halt auch ein Collection,

00:57:22.400 --> 00:57:25.400
ist halt ein Mapping sozusagen.

00:57:25.400 --> 00:57:28.400
Und ein Set ist keine Liste, aber ein Set ist schon eine Collection.

00:57:28.400 --> 00:57:30.400
Genau, das ist der dritte Basistyp.

00:57:30.400 --> 00:57:31.400
Aber keine Sequence.

00:57:31.400 --> 00:57:33.400
Genau, also das sind dann die Basistypen, die sie da ableiten.

00:57:33.400 --> 00:57:34.400
Sequence, Mapping und Set.

00:57:34.400 --> 00:57:35.400
Ach, Set auch, okay.

00:57:35.400 --> 00:57:37.400
Und die drei verhalten sich unterschiedlich.

00:57:37.400 --> 00:57:39.400
Und daraus, das sind aber die Dinge, man dann einsetzt.

00:57:39.400 --> 00:57:43.400
Also diese Bausteine, also ein pures Iterable, ich meine,

00:57:43.400 --> 00:57:46.400
geht prinzipiell schon, oder ein pures Sized.

00:57:46.400 --> 00:57:47.400
Ja.

00:57:47.400 --> 00:57:49.400
Ah, ist nicht nett, dass ich das schon mal gesehen habe.

00:57:49.400 --> 00:57:51.400
Aber natürlich Sequence und Mapping und Set,

00:57:51.400 --> 00:57:53.400
das sind die Sachen, die man dann tatsächlich benutzt.

00:57:53.400 --> 00:57:55.400
Weil da hast du dann die Bausteine zusammengesetzt zu dem,

00:57:55.400 --> 00:57:57.400
was man tatsächlich einfach braucht.

00:57:57.400 --> 00:57:59.400
Das, was dann sinnvoll ist.

00:57:59.400 --> 00:58:00.400
Ja.

00:58:00.400 --> 00:58:02.400
Und da kann man dann auch Beispiele sagen.

00:58:02.400 --> 00:58:05.400
Also ein Beispiel von einem Iterable könnte ich jetzt nicht unbedingt sagen.

00:58:05.400 --> 00:58:06.400
Also von einem puren.

00:58:06.400 --> 00:58:07.400
Ja, ein Huhn.

00:58:07.400 --> 00:58:09.400
Aber von einer Sequence ist easy.

00:58:09.400 --> 00:58:10.400
Ein Huhn.

00:58:10.400 --> 00:58:11.400
Ein Huhn ist ein Iterable.

00:58:11.400 --> 00:58:13.400
Liegt ein Ei, liegt noch ein Ei, liegt noch ein Ei, liegt noch ein Ei.

00:58:13.400 --> 00:58:14.400
Ja.

00:58:15.400 --> 00:58:18.400
Das wüsste ich jetzt nicht, wie man es in Python implementiert, aber ja.

00:58:18.400 --> 00:58:20.400
(Lachen)

00:58:20.400 --> 00:58:22.400
Es gibt auch Hühner in Python.

00:58:22.400 --> 00:58:24.400
Dann ist halt die Frage, was war zuerst da?

00:58:24.400 --> 00:58:25.400
Das Ei oder das Huhn?

00:58:25.400 --> 00:58:27.400
Ah, ja, weiß ich auch nicht.

00:58:27.400 --> 00:58:30.400
Wenn du eine große Schlange hast, kannst du ja mal einen Huhn reintun.

00:58:30.400 --> 00:58:32.400
Und dann schauen, ob es iteriert.

00:58:32.400 --> 00:58:34.400
Ich habe letztens irgendwo so ein Schaubild gesehen,

00:58:34.400 --> 00:58:36.400
wo ein Biologe meinte, so was, eine Quatschfrage.

00:58:36.400 --> 00:58:39.400
Also wir wahlen hier einfach mal so diesen evolutionären Stamm auf.

00:58:39.400 --> 00:58:43.400
Und dann haben wir überall Eier, aber nur da ganz unten ein Huhn.

00:58:43.400 --> 00:58:45.400
Natürlich war das Ei zuerst da.

00:58:45.400 --> 00:58:47.400
(Lachen)

00:58:47.400 --> 00:58:49.400
Völlig triviale Frage.

00:58:49.400 --> 00:58:50.400
Ja.

00:58:50.400 --> 00:58:51.400
Okay.

00:58:51.400 --> 00:58:52.400
Genau.

00:58:52.400 --> 00:58:54.400
Und Mapping, ich meine, das kennt man auch.

00:58:54.400 --> 00:58:55.400
Das ist ein Dictionary.

00:58:55.400 --> 00:58:56.400
Und Set kennt man auch.

00:58:56.400 --> 00:58:57.400
Das ist ein Set.

00:58:57.400 --> 00:58:59.400
Und das sind dann die Sachen, die man tatsächlich benutzt.

00:58:59.400 --> 00:59:02.400
Aber diese Protokolle, also das, was die tatsächlich an Funktionalität anbieten,

00:59:02.400 --> 00:59:05.400
das ist hier zusammengesetzt aus diesen ABCs,

00:59:05.400 --> 00:59:07.400
aus den Abstract Base Classes.

00:59:07.400 --> 00:59:09.400
Benutzt die das eigentlich immer?

00:59:09.400 --> 00:59:13.400
Der Trick ist, dass, wenn du diese ABCs implementierst,

00:59:13.400 --> 00:59:17.400
dann, genau wie vorhin bei den Special Methods oder bei den Magic Methods,

00:59:17.400 --> 00:59:20.400
dann kannst du dich in den Python-Interpreter so reinintegrieren,

00:59:20.400 --> 00:59:23.400
wie wenn du ein Dict wärst oder eine Liste oder was auch immer.

00:59:23.400 --> 00:59:24.400
Ja.

00:59:24.400 --> 00:59:26.400
Also dann habe ich ein Interface implementiert.

00:59:26.400 --> 00:59:28.400
Kann man das so sagen?

00:59:28.400 --> 00:59:30.400
Ja, es heißt hier nicht Interface, sondern Protokoll.

00:59:30.400 --> 00:59:31.400
Aha.

00:59:31.400 --> 00:59:34.400
Das heißt, beim Typing Protokoll kann ich das dann benutzen?

00:59:34.400 --> 00:59:36.400
Das ist nochmal eine andere Geschichte.

00:59:36.400 --> 00:59:39.400
Aber ja, das ist eine andere Art, das zu machen.

00:59:39.400 --> 00:59:40.400
Aber das macht quasi genau ...

00:59:40.400 --> 00:59:42.400
Also Abstract Base Classes, ja, braucht man das?

00:59:42.400 --> 00:59:43.400
Also du kannst ...

00:59:43.400 --> 00:59:45.400
Das Problem bei den Abstract Base Classes,

00:59:45.400 --> 00:59:47.400
das ist halt, es funktioniert halt anders.

00:59:47.400 --> 00:59:50.400
Es ist halt sozusagen, das hatten wir in der Typing-Episode auch,

00:59:50.400 --> 00:59:56.400
es ist halt sozusagen nominative Typisierung in dem Sinne,

00:59:56.400 --> 00:59:59.400
dass du jetzt bei jedem Ding, das du erzeugst,

00:59:59.400 --> 01:00:02.400
dadurch, dass du von so einer Abstract Base Class erbst,

01:00:02.400 --> 01:00:04.400
sagst du halt genau, was es ist.

01:00:04.400 --> 01:00:06.400
Und das ist das, weil man es davon erbt.

01:00:06.400 --> 01:00:08.400
Genau, bei Protokoll nicht, weil es kann so sein.

01:00:08.400 --> 01:00:11.400
Ich finde, das ist im Protokoll viel flexibler für so was

01:00:11.400 --> 01:00:13.400
und auch viel besser geeignet.

01:00:13.400 --> 01:00:18.400
Ja, aber es hat dann natürlich auch wieder Nachteile.

01:00:18.400 --> 01:00:20.400
Naja, wenn du sagst, es muss eine Collection sein,

01:00:20.400 --> 01:00:22.400
die da reingeht, dann ist doch scheißegal,

01:00:22.400 --> 01:00:24.400
was für eine Collection das ist.

01:00:24.400 --> 01:00:26.400
Weil das Protokoll der Collection erfüllt

01:00:26.400 --> 01:00:28.400
und die dann des Mappings oder des Sets oder so was.

01:00:28.400 --> 01:00:30.400
Und da ist irgendein Set, das da rein muss.

01:00:30.400 --> 01:00:32.400
Aber du sagst, es muss diese Sachen da drin haben,

01:00:32.400 --> 01:00:34.400
die im Protokoll definiert sind.

01:00:34.400 --> 01:00:37.400
Also in den Methoden, die man für ein Set halt braucht.

01:00:37.400 --> 01:00:39.400
Genau, aber das sagst du ja damit.

01:00:39.400 --> 01:00:41.400
Ja, aber dann ist das doch okay.

01:00:41.400 --> 01:00:43.400
Aber dann muss ich doch keine Abstract Base Class verwenden.

01:00:43.400 --> 01:00:45.400
Das ist irgendwie komisch.

01:00:45.400 --> 01:00:47.400
Doch, klar. Das ist ja genau die Formalisierung davon.

01:00:47.400 --> 01:00:49.400
Du erbst von dieser Abstract Base Class,

01:00:49.400 --> 01:00:51.400
dann hast du erst mal nichts umgesetzt,

01:00:51.400 --> 01:00:53.400
dann implementierst du die ganzen Sachen.

01:00:53.400 --> 01:00:54.400
Nein, Protokoll.

01:00:54.400 --> 01:00:57.400
Dann wirst du zu einer Collection. Deine Klasse ist eine Collection.

01:00:57.400 --> 01:00:59.400
Du kannst das auch überprüfen.

01:00:59.400 --> 01:01:01.400
Wenn du nur im Typing sagst, das entspricht dem,

01:01:01.400 --> 01:01:03.400
dann hast du das nicht überprüft.

01:01:03.400 --> 01:01:05.400
Wenn du ein Protokoll-Ding machst,

01:01:05.400 --> 01:01:07.400
dann würdest du sagen, ist Instance of Collection.

01:01:07.400 --> 01:01:09.400
Sagt ihr halt, ne, eher nicht.

01:01:09.400 --> 01:01:11.400
Was du dann machen kannst,

01:01:11.400 --> 01:01:15.400
ist halt, dein statischer Typechecker kann immer noch Fehler finden.

01:01:15.400 --> 01:01:17.400
Ja, genau.

01:01:17.400 --> 01:01:19.400
Mein Linter sagt mir halt,

01:01:19.400 --> 01:01:22.400
der will jetzt eine Collection haben und nichts anderes.

01:01:22.400 --> 01:01:25.400
Ja, aber wenn da jemand anders ein Instance auf deinem,

01:01:25.400 --> 01:01:27.400
was auch immer das Ding ist, irgendwie aufruft,

01:01:27.400 --> 01:01:30.400
dann kriegt der nicht und sagt, ist das eine Collection?

01:01:30.400 --> 01:01:32.400
Dann kommt er zurück, nö, ist nicht.

01:01:32.400 --> 01:01:34.400
Ja, okay, weil das kein hartes Geerbt ist.

01:01:34.400 --> 01:01:36.400
Weil es ist nicht wirklich eine Collection.

01:01:36.400 --> 01:01:39.400
Aber es interpretiert nur das Protokoll als wäre es eine Collection.

01:01:39.400 --> 01:01:42.400
Genau, also das ist quasi die Formalisierung davon.

01:01:42.400 --> 01:01:45.400
Du gibst es technisch rein und sagst, das ist eine Collection.

01:01:45.400 --> 01:01:48.400
Glaubst du der Sprache, die das Instance überhaupt hat,

01:01:48.400 --> 01:01:50.400
oder glaubst du deinem Linter, der dir sagt,

01:01:50.400 --> 01:01:52.400
das könnte passen oder nicht?

01:01:52.400 --> 01:01:54.400
Naja, es hat halt alle so Vor- und Nachteile.

01:01:54.400 --> 01:01:56.400
Den Linter glaub ich überhaupt gar nicht.

01:01:56.400 --> 01:01:58.400
Ja, aber warum will ich denn jemals testen,

01:01:58.400 --> 01:02:00.400
ob es Instance of Collections ist?

01:02:00.400 --> 01:02:03.400
Ich will nur wissen, ob das lintert, weil es die Methoden implementiert.

01:02:03.400 --> 01:02:06.400
Und ich will, ob es Instance of, keine Ahnung, meine Superliste ...

01:02:06.400 --> 01:02:08.400
Ja, nee, es ist halt so eine ...

01:02:08.400 --> 01:02:11.400
Da gibt es ja schon Use Cases dafür, dass du sagst, okay,

01:02:11.400 --> 01:02:13.400
hier hat eine Funktion, die alles Mögliche ...

01:02:13.400 --> 01:02:15.400
Oder es ist Instance ...

01:02:15.400 --> 01:02:18.400
Ich hab eine Funktion, die alles Mögliche verarbeiten kann,

01:02:18.400 --> 01:02:21.400
muss ja schon eventuell auf unterschiedliche Arten drücken.

01:02:21.400 --> 01:02:24.400
Ich will nur wissen, ob ich in einer Collection gucke.

01:02:24.400 --> 01:02:27.400
Und ich will niemals wissen, ob es eine Collection

01:02:27.400 --> 01:02:29.400
von irgendwelchen abstrakten Dingen ist.

01:02:29.400 --> 01:02:32.400
Deswegen ist es Bullshit, das mit abstrakten Base Classes.

01:02:32.400 --> 01:02:35.400
Meine Meinung nach ist es super, wenn es ein Fotovolg gibt.

01:02:35.400 --> 01:02:38.400
Damit du noch nie eine Bibliothek implementiert hast,

01:02:38.400 --> 01:02:41.400
die so eine Funktionalität anbietet, ist es jetzt schade, aber so ist es.

01:02:41.400 --> 01:02:44.400
Ich meine zum Beispiel, wo das halt häufig auftritt,

01:02:44.400 --> 01:02:47.400
also wo ich das kenne mit denen, dass man halt irgendwie,

01:02:47.400 --> 01:02:50.400
es gibt halt viele Methoden, zum Beispiel nehmen wir jetzt

01:02:50.400 --> 01:02:52.400
irgendwelche Modelle oder so.

01:02:52.400 --> 01:02:56.400
Und da kommen halt manchmal so wirklich komische Sachen rein.

01:02:56.400 --> 01:03:01.400
Und ich hab auch schon viel Scikit-Learn-Code zum Beispiel gelesen.

01:03:01.400 --> 01:03:06.400
Und so viele Methoden oder viele Funktionen, die fangen an mit,

01:03:06.400 --> 01:03:09.400
also, sag mal, bist du eigentlich ein so was?

01:03:09.400 --> 01:03:11.400
Oder bist du vielleicht so was?

01:03:11.400 --> 01:03:14.400
Und dann machen sie halt unterschiedliche Dinge,

01:03:14.400 --> 01:03:16.400
je nachdem, was das dann ist.

01:03:16.400 --> 01:03:19.400
Und das ist halt teilweise, das ist wirklich lang am Anfang.

01:03:19.400 --> 01:03:22.400
Und ich wüsste jetzt nicht, wie man das anders machen könnte,

01:03:22.400 --> 01:03:24.400
außer so.

01:03:24.400 --> 01:03:26.400
Also, ja.

01:03:26.400 --> 01:03:30.400
Eine Sorte Funktion, die man auch häufig sieht in Bibliotheken,

01:03:30.400 --> 01:03:33.400
ist, wo du entweder einzelne Elemente reingeben kannst

01:03:33.400 --> 01:03:35.400
oder gleich eine ganze Sammlung.

01:03:35.400 --> 01:03:38.400
Und dann musst du halt auch am Anfang dieser Funktion

01:03:38.400 --> 01:03:40.400
in der Implementierung unterscheiden können,

01:03:40.400 --> 01:03:43.400
ob du jetzt gerade ein einzelnes Element in der Hand hast

01:03:43.400 --> 01:03:45.400
oder ganz viele einzelne Elemente.

01:03:45.400 --> 01:03:48.400
Und da musst du schon irgendwie eine formalisierte Unterscheidung machen.

01:03:48.400 --> 01:03:50.400
Da geht es ja zur Laufzeit nicht.

01:03:50.400 --> 01:03:55.400
Also, es macht schon seinen Sinn, diese Sachen so zu deklarieren,

01:03:55.400 --> 01:03:58.400
insbesondere, wenn du eben hier solche, sag ich mal,

01:03:58.400 --> 01:04:01.400
grundlegenden Funktionen implementierst.

01:04:01.400 --> 01:04:03.400
Man kann das auch zu weit treiben.

01:04:03.400 --> 01:04:06.400
Wenn man das zu weit treibt, dann kriegt man Java.

01:04:06.400 --> 01:04:10.400
Und man muss da eine Balance finden.

01:04:10.400 --> 01:04:16.400
Aber es ist, um wieder darauf zurückzukommen,

01:04:16.400 --> 01:04:18.400
es ist schon interessant, dass das eigentlich so

01:04:18.400 --> 01:04:20.400
relativ simple Sachen sind.

01:04:20.400 --> 01:04:23.400
Also hier dieses UML-Diagramm ist eine Viertelseite.

01:04:23.400 --> 01:04:26.400
Und es stehen ja wirklich nicht viele Sachen da drin.

01:04:26.400 --> 01:04:29.400
Es sind nicht viele Methoden, die man umsetzen muss.

01:04:29.400 --> 01:04:31.400
Ja, und das ist halt irgendwie quasi,

01:04:31.400 --> 01:04:34.400
also die meisten oder viele Leute werden sich niemals

01:04:34.400 --> 01:04:37.400
aus diesem Universum von dem, was da definiert ist, rausbewegen.

01:04:37.400 --> 01:04:39.400
Weil damit quasi fast alles erschlagen ist,

01:04:39.400 --> 01:04:41.400
was man so normalerweise so tut.

01:04:41.400 --> 01:04:44.400
Das ist schon faszinierend, dass das geht, ja.

01:04:44.400 --> 01:04:47.400
Außer Skalare, okay, die stehen da jetzt auch nicht drinnen.

01:04:47.400 --> 01:04:49.400
[lacht]

01:04:49.400 --> 01:04:51.400
Ja.

01:04:51.400 --> 01:04:53.400
Und dann ist das erste Kapitel ja schon fast vorbei.

01:04:53.400 --> 01:04:56.400
Dann haben wir noch hier die Übersicht der Dunder Methods.

01:04:56.400 --> 01:04:59.400
Da wird einmal noch mal komplett alle aufgeführt.

01:04:59.400 --> 01:05:02.400
Schön, so völlig ohne Zusammenhang hier mit Metaprogramming

01:05:02.400 --> 01:05:05.400
und Abstract Base Classes und Attribute Descriptors

01:05:05.400 --> 01:05:07.400
und Attribute Management.

01:05:07.400 --> 01:05:10.400
Also da ist es interessant, da reinzuschauen,

01:05:10.400 --> 01:05:12.400
was es alles gibt.

01:05:12.400 --> 01:05:14.400
Ich wüsste jetzt nicht bei allen, was die tun.

01:05:14.400 --> 01:05:17.400
Was ist der Unterschied zwischen GetAttribute und GetAttribute?

01:05:17.400 --> 01:05:19.400
Ja, es kommt in Kapitel ...

01:05:19.400 --> 01:05:21.400
[lacht]

01:05:21.400 --> 01:05:23.400
Ja.

01:05:23.400 --> 01:05:27.400
Also das eine ist irgendwie noch mal ein Stückchen allgemeiner,

01:05:27.400 --> 01:05:29.400
glaube ich, als das andere.

01:05:29.400 --> 01:05:32.400
Ich glaube, GetAttribute ist halt das wirklich ganz allgemeine Ding

01:05:32.400 --> 01:05:34.400
und GetAttribute guckt halt wirklich ...

01:05:34.400 --> 01:05:36.400
Ganz tief runter.

01:05:36.400 --> 01:05:38.400
Das eine ist näher dran, oder?

01:05:38.400 --> 01:05:40.400
Ja, also GetAttribute kannst du auch,

01:05:40.400 --> 01:05:42.400
aber damit kannst du auch Methoden übersteuern.

01:05:42.400 --> 01:05:45.400
Genau, die Frage ist halt, wann, welches Stick das reinguckt,

01:05:45.400 --> 01:05:47.400
wenn du guckst.

01:05:47.400 --> 01:05:50.400
Aber so ganz genau weiß ich das jetzt auch alles nicht.

01:05:50.400 --> 01:05:52.400
Oder InitSubclass.

01:05:52.400 --> 01:05:55.400
Wüsstest du, was InitSubclass macht, Jochen, oder Prepare?

01:05:55.400 --> 01:05:57.400
Ich weiß es aus einem ...

01:05:57.400 --> 01:05:59.400
[unverständlich]

01:05:59.400 --> 01:06:01.400
InitSubclass, das ist halt ...

01:06:01.400 --> 01:06:04.400
Der Grund, warum Leute Metaclusten verwenden, ist eigentlich der,

01:06:04.400 --> 01:06:07.400
dass sie halt irgendwie die Clust-Instanzierung ab und zu

01:06:07.400 --> 01:06:09.400
mal so ein bisschen modifizieren wollen.

01:06:09.400 --> 01:06:13.400
Also Metaclusten selber zum Benutzen ist super viertelig.

01:06:13.400 --> 01:06:15.400
Man muss extrem aufpassen, was man da tut.

01:06:15.400 --> 01:06:20.400
Und daher ist das halt so ein bisschen auch in Verruf geraten

01:06:20.400 --> 01:06:22.400
und Leute raten einem davon immer, auf das zu machen.

01:06:22.400 --> 01:06:30.400
Aber genau, man kann, wenn man jetzt InitSubclass verwendet,

01:06:30.400 --> 01:06:32.400
dann kann man fast alle Anwendungsfälle, für die Leute

01:06:32.400 --> 01:06:35.400
normalerweise so Metaclusten verwenden, halt damit hinkriegen

01:06:35.400 --> 01:06:38.400
und hat all diese Probleme nicht, die man halt sonst so kriegt,

01:06:38.400 --> 01:06:40.400
wenn man Metaclusten verwendet.

01:06:40.400 --> 01:06:43.400
Und das ist eingeführt worden mit Python 3.6.

01:06:43.400 --> 01:06:46.400
Und ich weiß das halt nicht deswegen, weil ich sowieso immer alles weiß,

01:06:46.400 --> 01:06:48.400
sondern in dem speziellen Fall ...

01:06:48.400 --> 01:06:50.400
[lacht]

01:06:50.400 --> 01:06:52.400
In dem speziellen Fall schon.

01:06:52.400 --> 01:06:56.400
In diesem Fall weiß ich es, weil den Pep dafür hat irgendwie ...

01:06:56.400 --> 01:06:58.400
Wir hatten ja Martin hier auch mal zu Gast,

01:06:58.400 --> 01:07:01.400
der irgendwie dann diesen xfile-ronken-Laser geschrieben hat.

01:07:01.400 --> 01:07:04.400
Und den Pep zur Einführung von InitSubclass,

01:07:04.400 --> 01:07:07.400
den hat er geschrieben und ist damals in Python 3.6 reingekommen.

01:07:07.400 --> 01:07:09.400
Und deswegen hast du natürlich ganz besonders ...

01:07:09.400 --> 01:07:11.400
Okay, dann habe ich jetzt das Falsche gefragt.

01:07:11.400 --> 01:07:14.400
Dann sag mal, was SubclassCheck macht, Jochen, weißt du mal alles?

01:07:14.400 --> 01:07:16.400
Ja, siehste, weiß ich nicht, keine Ahnung.

01:07:16.400 --> 01:07:19.400
Ja, okay, gut. Also das kommt dann in einem späteren Kapitel.

01:07:19.400 --> 01:07:21.400
Und da sind auch MRO-Entries.

01:07:21.400 --> 01:07:23.400
Also ich meine, dass man da sein MRO bearbeiten kann,

01:07:23.400 --> 01:07:25.400
das ist ja schon hart.

01:07:25.400 --> 01:07:29.400
Kann man sich einfach sagen, ich bin jetzt ein bisschen tiefer implementiert

01:07:29.400 --> 01:07:31.400
und ich bin jetzt einfach Type.

01:07:31.400 --> 01:07:33.400
Ja, keine Ahnung, ich weiß es nicht.

01:07:33.400 --> 01:07:35.400
[lacht]

01:07:35.400 --> 01:07:38.400
Wir werden es im Laufe dieser Vortragsreihe,

01:07:38.400 --> 01:07:41.400
eine Type vielleicht lernen.

01:07:41.400 --> 01:07:44.400
Genau, aber was mich auch überrascht hat, ist das, wie viel ...

01:07:44.400 --> 01:07:46.400
Oder machen wir jetzt das ganze Buch heute.

01:07:46.400 --> 01:07:48.400
[lacht]

01:07:48.400 --> 01:07:50.400
Also keine Zeit.

01:07:50.400 --> 01:07:53.400
Einmal anschneiden, Türen schließen.

01:07:53.400 --> 01:07:57.400
Was ich auch irgendwie nicht erwartet hätte,

01:07:57.400 --> 01:08:01.400
also ist das halt so viel Zeug sich um arithmetische Geschichten

01:08:01.400 --> 01:08:04.400
und Operator-Overloading handelt.

01:08:04.400 --> 01:08:06.400
Mehr als die Hälfte.

01:08:06.400 --> 01:08:09.400
Und das hätte ich jetzt nicht gedacht.

01:08:09.400 --> 01:08:11.400
Wenn man mich jetzt nachts geweckt hätte und gefragt hätte,

01:08:11.400 --> 01:08:14.400
welche Magic Messes gibt es und was machen die so,

01:08:14.400 --> 01:08:18.400
dann wäre ich jetzt bei sowas wie Repre oder irgendwie, genau,

01:08:18.400 --> 01:08:20.400
Bool oder weiß ich nicht, sowas gewesen.

01:08:20.400 --> 01:08:22.400
Augmented Bitwise Arithmetic.

01:08:22.400 --> 01:08:24.400
Ja, aber ...

01:08:24.400 --> 01:08:27.400
Ja, es geht in beide Richtungen und dann geht es mit Integer

01:08:27.400 --> 01:08:29.400
und dann gibt es mit Reversed und dann gibt es mit Augmented

01:08:29.400 --> 01:08:32.400
und dann gibt es mit Bitwise und mit Reversed und Augmented.

01:08:32.400 --> 01:08:36.400
Das gibt es alles in drei verschiedenen Varianten jeweils.

01:08:36.400 --> 01:08:41.400
Sonst sind es ja nicht so viele, aber ...

01:08:41.400 --> 01:08:43.400
Ja.

01:08:43.400 --> 01:08:44.400
Ja, ja, ja.

01:08:44.400 --> 01:08:46.400
Ja gut, Mathematik regiert die Welt.

01:08:46.400 --> 01:08:48.400
Ja. [lacht]

01:08:48.400 --> 01:08:50.400
Das, das, ja.

01:08:50.400 --> 01:08:52.400
So ist es.

01:08:52.400 --> 01:08:53.400
Ja.

01:08:53.400 --> 01:08:55.400
Ja, dann, das ist doch interessant hier.

01:08:55.400 --> 01:09:00.400
Und am Ende seines Kapitels hat er immer noch einen Soapbox-Abschnitt.

01:09:00.400 --> 01:09:02.400
Den finde ich auch sehr schön.

01:09:02.400 --> 01:09:04.400
Ja, ja, genau, wo er sich hinstellt und mal ein bisschen predigt.

01:09:04.400 --> 01:09:08.400
Und das, das fand ich hier tatsächlich auch sehr schön.

01:09:08.400 --> 01:09:12.400
The Art of the Meta-Object Protocol.

01:09:12.400 --> 01:09:16.400
Großartiger Buchtitel und habe ich mir jetzt auch mal auf meine Liste ...

01:09:16.400 --> 01:09:18.400
Das musst du noch mal genau erklären, bitte.

01:09:18.400 --> 01:09:20.400
Ne, ich weiß es auch nicht, ich habe es auch noch nicht gelesen,

01:09:20.400 --> 01:09:22.400
aber ich fand den Titel gut genug, dass ich es mir direkt

01:09:22.400 --> 01:09:26.400
auf meine Leseliste gesetzt habe.

01:09:26.400 --> 01:09:29.400
Was ich viel interessanter fand noch, war ganz am Ende was,

01:09:29.400 --> 01:09:33.400
er sagt hier, der Autor, der dieses AMOP-Buch geschrieben hat,

01:09:33.400 --> 01:09:35.400
The Art of the Meta-Object Protocol,

01:09:35.400 --> 01:09:39.400
der hat aspect-oriented programming entwickelt oder getrieben.

01:09:39.400 --> 01:09:43.400
Und ich habe es dann mal auf Wikipedia nachgelesen,

01:09:43.400 --> 01:09:47.400
was aspect-oriented programming ist, aber nicht so richtig verstanden.

01:09:47.400 --> 01:09:51.400
Also Aspekte sind auch irgendwas mit Magie, oder?

01:09:51.400 --> 01:09:53.400
Da geht es entweder um Wasser oder Feuer oder ...

01:09:53.400 --> 01:09:55.400
Ja, es ...

01:09:55.400 --> 01:09:57.400
Irgendwas mit gegen die Muggel.

01:09:57.400 --> 01:09:59.400
Ja, vielleicht. Ich weiß es nicht.

01:09:59.400 --> 01:10:01.400
Ja, muss uns mal jemand erklären.

01:10:01.400 --> 01:10:03.400
Ich würde gerne mehr wissen, wie es geht.

01:10:03.400 --> 01:10:06.400
Aber da sind auf jeden Fall in dieser Soapbox schöne Pointer drin,

01:10:06.400 --> 01:10:12.400
wo man dann dem geneigten Leser als Übungsaufgabe überlassen wird.

01:10:12.400 --> 01:10:16.400
Vielleicht werden die Designer von Goo irgendwann das Meta-Objekt-Protokoll erweitern.

01:10:16.400 --> 01:10:21.400
Aber das ist im Moment nicht das, was man auf dem Niveau mit dem man

01:10:21.400 --> 01:10:23.400
im Python arbeiten kann.

01:10:23.400 --> 01:10:25.400
Genau, das ist halt das, was er hier dann sagt.

01:10:25.400 --> 01:10:28.400
In anderen Sprachen hast du die Möglichkeit nicht.

01:10:28.400 --> 01:10:30.400
In Goo gibt es tatsächlich Magic-Sachen,

01:10:30.400 --> 01:10:32.400
weil die halt im Interpreter drin sind, kommst du auch nicht dran,

01:10:32.400 --> 01:10:34.400
kannst nichts machen.

01:10:34.400 --> 01:10:36.400
Und Pech gehabt.

01:10:36.400 --> 01:10:38.400
Und das ist ja in Python eben nicht so.

01:10:38.400 --> 01:10:40.400
Deshalb hier Muggel-Methods.

01:10:40.400 --> 01:10:43.400
Jeder kann da hingehen und die Finger drauflegen

01:10:43.400 --> 01:10:45.400
und dann so tun, als ob er zu Python gehört.

01:10:45.400 --> 01:10:47.400
[lacht]

01:10:47.400 --> 01:10:51.400
Du wolltest damit einen exklusiven Kreis aufmachen, lieber Johannes.

01:10:51.400 --> 01:10:53.400
Du musst nur die magischen Worte wissen

01:10:53.400 --> 01:10:55.400
und dann in der richtigen Reihenfolge sagen

01:10:55.400 --> 01:10:57.400
und dann deinen Zauberstab in der richtigen Bewegung schwingen.

01:10:57.400 --> 01:10:59.400
Ja, du musst aber schon noch in jede Ecke vom Raum

01:10:59.400 --> 01:11:01.400
schon eine Kerze reinstellen und so.

01:11:01.400 --> 01:11:04.400
Das ist dann das Meta-Programming, was du da meinst.

01:11:04.400 --> 01:11:07.400
[lacht]

01:11:07.400 --> 01:11:09.400
Und Meta-Klasse.

01:11:09.400 --> 01:11:11.400
Ja.

01:11:11.400 --> 01:11:13.400
Da muss man immer ein bisschen aufpassen,

01:11:13.400 --> 01:11:15.400
was man da mit sich heraufbeschwört.

01:11:15.400 --> 01:11:17.400
Wenn man zu viel Meta macht, dann kann das auch.

01:11:17.400 --> 01:11:19.400
Zu viel Magie.

01:11:19.400 --> 01:11:21.400
Ja.

01:11:21.400 --> 01:11:23.400
Marry meet, marry greet.

01:11:23.400 --> 01:11:25.400
And marry meet again.

01:11:25.400 --> 01:11:29.400
Also wegen des Heraufbeschworens.

01:11:29.400 --> 01:11:32.400
Das erste Kapitel war nicht so lang.

01:11:32.400 --> 01:11:34.400
Nö, du warst überrascht.

01:11:34.400 --> 01:11:40.400
Es fängt ordentlich an und ist dann aber nach 19 Seiten schon vorbei.

01:11:40.400 --> 01:11:43.400
Also das fand ich überraschend.

01:11:43.400 --> 01:11:46.400
Der legt ordentlich los und macht dann aber gleich direkt eine Pause.

01:11:46.400 --> 01:11:49.400
[lacht]

01:11:49.400 --> 01:11:53.400
Ja, danach kommen dann jetzt Sequences und Bits und Sets.

01:11:53.400 --> 01:11:55.400
Ja, das ist ja deutlich länger.

01:11:55.400 --> 01:11:57.400
Da hat man schon mal drüber gesprochen.

01:11:57.400 --> 01:11:59.400
Dann hat man schon mal drüber gesprochen,

01:11:59.400 --> 01:12:01.400
wir können einfach ein bisschen weiter.

01:12:01.400 --> 01:12:04.400
Pattern-Matching ist ja auch sowas, das haben wir auch noch nie wirklich ausführlich besprochen.

01:12:04.400 --> 01:12:06.400
Das sollten wir vielleicht auch mal tun.

01:12:06.400 --> 01:12:08.400
Das gibt es in Kapitel 2.

01:12:08.400 --> 01:12:10.400
Das ist tatsächlich etwas über 60 Seiten lang.

01:12:10.400 --> 01:12:12.400
Das ist dann gleich deutlich länger.

01:12:12.400 --> 01:12:15.400
Aber ich meine, wenn man auf 980 Seiten kommen will,

01:12:15.400 --> 01:12:18.400
muss man ab und zu mal eine füllen.

01:12:18.400 --> 01:12:20.400
Kapitel machen.

01:12:20.400 --> 01:12:22.400
[lacht]

01:12:22.400 --> 01:12:24.400
Wie viele Kapitel gibt es denn?

01:12:24.400 --> 01:12:26.400
Ich habe gar nicht nachgeguckt.

01:12:26.400 --> 01:12:28.400
Ich habe einfach losgelesen, ohne zu lesen, wie viele Kapitel es gibt.

01:12:28.400 --> 01:12:31.400
Du hast ja viele, 900 Seiten. Hast du ein bisschen Platz?

01:12:31.400 --> 01:12:33.400
24 Kapitel gibt es.

01:12:33.400 --> 01:12:35.400
Hätten es 25 sein sollen?

01:12:35.400 --> 01:12:37.400
Oder wie ist eine andere von den magischen Zahlen,

01:12:37.400 --> 01:12:39.400
damit man auch in die richtige Stelle kommt?

01:12:39.400 --> 01:12:41.400
Nee, 24 ist doch gut.

01:12:41.400 --> 01:12:44.400
Das ist eine Abundant Number, oder?

01:12:44.400 --> 01:12:48.400
Das ist doch eine, wo die Summe der Teile größer ist als die Zahl selbst.

01:12:48.400 --> 01:12:50.400
Okay.

01:12:50.400 --> 01:12:52.400
Das ist doch immer gut.

01:12:52.400 --> 01:12:54.400
Aha.

01:12:54.400 --> 01:12:57.400
Ja, jetzt kommen die Mathe-Nerds raus.

01:12:57.400 --> 01:12:59.400
[lacht]

01:12:59.400 --> 01:13:01.400
Okay, kannte ich auch noch nicht.

01:13:01.400 --> 01:13:03.400
Ja.

01:13:03.400 --> 01:13:06.400
Da habe ich eine Buchempfehlung dazu, wenn dich das interessiert.

01:13:06.400 --> 01:13:08.400
These Wonderful Numbers.

01:13:08.400 --> 01:13:13.400
Da ist quasi zu jeder Zahl sind die Eigenschaften beschrieben.

01:13:13.400 --> 01:13:15.400
[lacht]

01:13:15.400 --> 01:13:17.400
Hm.

01:13:17.400 --> 01:13:21.400
Das ist ein sehr nerdiges Buch für nerdige Mathematiker.

01:13:21.400 --> 01:13:25.400
Einfach keine Angst haben, die Dunkelheit länger ins Auge zu schauen.

01:13:25.400 --> 01:13:27.400
Je älter man wird, desto mehr versteht man davon auch.

01:13:27.400 --> 01:13:30.400
Ach ja, als Mathematiker hat man da keine Angst davor.

01:13:30.400 --> 01:13:33.400
Hat auch wieder was mit Magie zu tun.

01:13:33.400 --> 01:13:35.400
Worte der Weisheit.

01:13:35.400 --> 01:13:37.400
Genau, spezielle Art von Magie.

01:13:37.400 --> 01:13:39.400
Genau.

01:13:39.400 --> 01:13:42.400
Da wir die ganze Zeit von Magie reden, würde ich gerne meinen Pick tatsächlich nehmen.

01:13:42.400 --> 01:13:44.400
Oh.

01:13:44.400 --> 01:13:46.400
[lacht]

01:13:46.400 --> 01:13:57.400
Ich nehme doch täglich noch einen European Talk, weil der liebe Rodrigo einen sehr schönen Talk gemacht hat über so Törtel.

01:13:57.400 --> 01:13:59.400
Kennt ihr vielleicht.

01:13:59.400 --> 01:14:01.400
Auch ganz magische Sachen macht das.

01:14:01.400 --> 01:14:05.400
Das kann Dinge auf die Leinwand malen, die sich drehen, spiralen.

01:14:05.400 --> 01:14:07.400
Und dann kann man das erweitern, auch zu Fraktalen.

01:14:07.400 --> 01:14:13.400
Dann kann man animierte Fraktale für Live-Performances zum Beispiel schreiben.

01:14:13.400 --> 01:14:17.400
Und zwar relativ einfach, indem man so einfache mathematische Prinzipien verwendet.

01:14:17.400 --> 01:14:20.400
Und der war ein toller Talk zu, der hat auch einen schönen Blockbuster dazu geschrieben.

01:14:20.400 --> 01:14:22.400
Deswegen würde ich den gerne mal in die Schulung zwingen.

01:14:22.400 --> 01:14:24.400
Okay, okay.

01:14:24.400 --> 01:14:26.400
Okay, gut, cool, spannend.

01:14:26.400 --> 01:14:28.400
Mhm.

01:14:28.400 --> 01:14:31.400
Ich habe heute zwei Picks dabei.

01:14:31.400 --> 01:14:32.400
Aha.

01:14:32.400 --> 01:14:37.400
Der erste Pick ist ein Buch ähnlichen Ausmaßes wie Fluent Python.

01:14:37.400 --> 01:14:40.400
Ich halte mal hier die Kamera für die anderen beiden.

01:14:40.400 --> 01:14:41.400
Oh, okay.

01:14:41.400 --> 01:14:45.400
Als es kam, ist es ein tatsächlich ähnliches Format.

01:14:45.400 --> 01:14:50.400
Es heißt "Django 5 by Example" von Antonio Mele.

01:14:50.400 --> 01:14:58.400
Und ich glaube, dass das ähnlich ist wie Fluent Python, nur halt für Django.

01:14:58.400 --> 01:14:59.400
Sehr cool.

01:14:59.400 --> 01:15:01.400
Ganz frisch mit Django 5.

01:15:01.400 --> 01:15:04.400
Ich habe es leider noch nicht durchgelesen.

01:15:04.400 --> 01:15:12.400
Es ist, wie gesagt, auch dieses Buch hat 750 Seiten, ein bisschen weniger, aber trotzdem ähnliches Format.

01:15:12.400 --> 01:15:17.400
Was ist das mit diesen Autoren von Programmierhandbüchern?

01:15:17.400 --> 01:15:19.400
Warum müssen die immer so viel schreiben?

01:15:19.400 --> 01:15:20.400
Ach, ich weiß auch nicht.

01:15:20.400 --> 01:15:21.400
Ist doch viel Zeit.

01:15:21.400 --> 01:15:22.400
Es gibt viel zu sagen.

01:15:22.400 --> 01:15:24.400
Ja, gut.

01:15:24.400 --> 01:15:35.400
Ich glaube, der Trick da drin ist, dass es "by example" ist und sehr viele handfeste Projekte enthält,

01:15:35.400 --> 01:15:41.400
wo er sagt, wir machen jetzt mal einen Blog und jetzt machen wir noch mehr Blog und jetzt machen wir noch mehr Blog

01:15:41.400 --> 01:15:46.400
und jetzt machen wir noch Social Website und Social Authentication und Content Sharing und Online Shop

01:15:46.400 --> 01:15:51.400
und Tracking User Actions und Managing Payments and Orders and Extending Your Shop

01:15:51.400 --> 01:15:57.400
und Internationalization und Caching und E-Learning und Content Management und API.

01:15:57.400 --> 01:16:06.400
Das geht so ein bisschen in die Richtung, wo auch Fluent Python hingeht, dass es halt über die Basics hinausgeht.

01:16:06.400 --> 01:16:13.400
Und ich glaube, dass das eine Lücke in meinem Bücherschrank füllt, von der ich bisher nicht wusste, dass ich sie hatte.

01:16:13.400 --> 01:16:15.400
Und das freut mich sehr.

01:16:15.400 --> 01:16:20.400
Also hast du jetzt endlich Zeit, deinen Django-Webshop zu implementieren, von dem du schon die ganze Zeit träumst?

01:16:20.400 --> 01:16:26.400
Mein Blog, ich werde jetzt endlich mal meinen Blog modernisieren.

01:16:26.400 --> 01:16:29.400
Ja, genau. Generators, das war gestern, jetzt ist es wieder.

01:16:29.400 --> 01:16:34.400
Ja, nee, das ist doch langweilig. Ich muss dynamisch sein und mit User Tracking und mit Payments and Orders.

01:16:34.400 --> 01:16:38.400
Ja, das würde ja auch mal Zeit.

01:16:38.400 --> 01:16:39.400
Ja, ja, klar.

01:16:39.400 --> 01:16:44.400
Roi, roi, roi. Wieder Magie.

01:16:44.400 --> 01:16:51.400
Der zweite Pick, den ich mitgebracht habe, ist eine Bibliothek, die heißt Dramatik oder vielleicht heißt sie auch Dramatic Queue.

01:16:51.400 --> 01:16:58.400
Und das kam auf in einer Diskussion über, was kann man denn statt Celery verwenden?

01:16:58.400 --> 01:17:05.400
Da gibt es jetzt zwar in Django was, die Background Tasks, hatten wir ja vorhin auch schon kurz.

01:17:05.400 --> 01:17:08.400
Ja, hast du den selben Mastodon Social Thread gelesen?

01:17:08.400 --> 01:17:17.400
Ja, auf dem Bayer. Und ich habe mir aber die Links rausgeklickt. Und einer, der mir ins Auge gestochen ist, war eben Dramatic, was auch so ein Queueing System ist,

01:17:17.400 --> 01:17:23.400
was aber ein bisschen eine pythonischere Syntax hat als Celery jetzt zum Beispiel.

01:17:23.400 --> 01:17:30.400
Und das sah auf den ersten Blick sehr gut aus und ich freue mich da drauf, das irgendwann mal einsetzen zu können.

01:17:30.400 --> 01:17:34.400
Hm, ja, stimmt. Habe ich mir auch angeguckt. Das klingt tatsächlich nett.

01:17:34.400 --> 01:17:41.400
Ich hatte noch keine Zeit und habe mir gedacht, wenn ich jetzt eh noch bis April warten darf, bis Django Background Task rauskommt, dann spare ich mir einfach.

01:17:41.400 --> 01:17:46.400
Du kannst es auch jetzt schon verwenden. Also ich meine, es ist noch nicht wirklich dafür gedacht, dass man es jetzt verwendet,

01:17:46.400 --> 01:17:52.400
aber Django Task ist ja sozusagen, du kannst es einfach installieren und dann verwenden. Geht.

01:17:52.400 --> 01:17:56.400
Ja, ja, warum eigentlich nicht?

01:17:56.400 --> 01:18:08.400
Kann vielleicht noch zu wenig, aber ja. Also ist auf jeden Fall eine gute Idee, wenn man das noch nicht gemacht hat, einfach mal das auszuprobieren,

01:18:08.400 --> 01:18:13.400
weil dann muss man nichts mehr umstellen, wenn es dann irgendwann tatsächlich rauskommt.

01:18:13.400 --> 01:18:17.400
Ja, also es gibt so ein paar Module. Wie heißt das, Django Background Task tatsächlich?

01:18:17.400 --> 01:18:20.400
Django Tasks heißt das Paket. Das ist irgendwie komisch.

01:18:20.400 --> 01:18:22.400
Ja, so ist sein Name.

01:18:22.400 --> 01:18:29.400
Und Django Tasks ist tatsächlich gut im Vergleich dazu. Und Django Background Task gibt es auch und das wird man schwer wieder loswerden.

01:18:29.400 --> 01:18:32.400
Ja, ich verlinke das dann, aber es ist genau.

01:18:32.400 --> 01:18:41.400
Es gibt mehrere Module, die ähnlich benannt sind, die alle versuchen, was ähnliches zu tun oder mal so oder so naiv implementiert sind und dann relativ anstrengend wieder zu enden.

01:18:41.400 --> 01:18:45.400
Wie auch immer, also Django Tasks ist, glaube ich, das, was wir nehmen wollen.

01:18:45.400 --> 01:18:57.400
Genau, ja, was ich jetzt, ich habe, ich weiß nicht, ist auch etwas Spezielleres, was jetzt gar nicht so viel mit Pipelines zu tun hat.

01:18:57.400 --> 01:18:59.400
Du warst einfach nur auf Shoppingtour.

01:18:59.400 --> 01:19:11.400
Ja, aber ich finde das ganz interessant, weil ich habe ganz lange jetzt so Dinge verwendet, wie, also ich habe auch schon mal, also ich mache mal so.

01:19:11.400 --> 01:19:13.400
Du hast doch erst Geburtstag, Jochen.

01:19:13.400 --> 01:19:16.400
Aber ich brauche es ja für was anderes.

01:19:16.400 --> 01:19:23.400
Ich habe auch tatsächlich irgendwie mal vor, mal, mal wieder, also ich werde es nicht schaffen, irgendwie, ich wollte mal Videos machen, mehr, wieder.

01:19:23.400 --> 01:19:27.400
Und dann, da brauche ich natürlich auch entsprechendes Equipment für.

01:19:27.400 --> 01:19:30.400
Da soll ich jetzt zunächst mal meine Euroracks-Sammlung picken, wenn ich das kriege.

01:19:30.400 --> 01:19:32.400
Ja, mach das, finde es gut.

01:19:32.400 --> 01:19:38.400
Also wie kriegt man eigentlich quasi Bilder von der Kamera irgendwie auf den Rechner?

01:19:38.400 --> 01:19:41.400
Und ich habe auch schon sowas wie Lightroom verwendet oder so, früher mal.

01:19:41.400 --> 01:19:43.400
Und dann irgendwann dachte ich mir, ach, das brauche ich alles nicht mehr.

01:19:43.400 --> 01:19:51.400
Und dann habe ich irgendwie teilweise auch eine Zeit lang sogar Apple Fotos verwendet und fand das ganz okay, weil ich muss ja nicht viel machen und es hat geklappt.

01:19:51.400 --> 01:20:00.400
Und jetzt geht das aber nicht mehr, weil die RAW-Files, die aus der Kamera ausfallen, die mag Apple Fotos nicht mehr.

01:20:00.400 --> 01:20:02.400
Ich habe eine neue Kamera gekauft.

01:20:02.400 --> 01:20:14.400
Ja, und da gibt es aber dann vom Hersteller, von Nikon, gibt es halt ein Nikon NX Studio und die Software kann dann halt tatsächlich das RAW-Format lesen.

01:20:14.400 --> 01:20:28.400
Und das, was cool ist, das wusste ich gar nicht, dass das geht, das versteht das so gut, dass es halt irgendwie auch die, also quasi Profile für alle möglichen Dinge aus der Kamera drin hat.

01:20:28.400 --> 01:20:35.400
Das heißt, wenn du das halt jetzt in der Kamera schon so eingestellt hast, dann kriegst du das halt automatisch mit rein oder sowas bei anderen, bei Lightroom oder so eben nicht kriegst.

01:20:35.400 --> 01:20:47.400
Und du kannst auch dann dir deine eigenen Profile zusammenstellen und wieder auf die Kamera speichern und dann kannst du halt Bilder machen, die genauso sind, wie dein Look halt aussehen soll und so.

01:20:47.400 --> 01:20:49.400
Das heißt, du kannst den vorher vorprogrammieren?

01:20:49.400 --> 01:21:01.400
Ja, ja, also das ist wirklich, man kann damit halt Dinge machen, die sonst nicht so richtig gehen. Das fand ich ganz nett. Und also viele Leute schwärmen da auch von, dass das halt irgendwie mit den Farben richtig umgeht und solche Sachen, was halt immer so ein Problem ist bei Fotos.

01:21:01.400 --> 01:21:07.400
Und das ist alles richtig und das ist wirklich faszinierend, das kann mehr als man so erwartet. Auf der anderen Seite ist es halt unfassbar schlecht programmiert.

01:21:07.400 --> 01:21:15.400
Unglaublich, also einmal ist es ultra langsam und dann ist, also man kann es halt nur so ein paar Minuten lang verwenden und dann verbraucht man irgendwie.

01:21:15.400 --> 01:21:20.400
Das klingt halt so noch ein neues Hobby, du hast ja gerade schon Computerspiele in Rust programmiert, das wird's wetter.

01:21:20.400 --> 01:21:32.400
Ja, ja, vielleicht zu viel Zeit, ich weiß nicht genau. Aber also das leckt halt unglaublich, was Speicher angeht und das verbraucht halt irgendwie innerhalb von, so nach einer halben Stunde sind die 32 Gigabyte weg und dann muss man es neu starten.

01:21:32.400 --> 01:21:34.400
Was natürlich irgendwie echt totaler Quatsch ist, aber.

01:21:34.400 --> 01:21:37.400
Hast du nicht genug Speicher oder musst du neu starten?

01:21:37.400 --> 01:21:39.400
Nee, das ist halt alles.

01:21:39.400 --> 01:21:41.400
Wieso hast du nur so wenig Speicher, Jochen?

01:21:41.400 --> 01:21:46.400
Ich bin nicht nur GPU pur, ich bin auch RAM pur.

01:21:46.400 --> 01:21:48.400
Ja, nur 32 Gigabyte.

01:21:48.400 --> 01:21:52.400
Ja, das ist schon ziemlich lächerlich, muss ich auch sagen, stimmt.

01:21:52.400 --> 01:22:01.400
Aber ja genau, also da kann man nicht genug, kann man irgendwie mit dem RAM kaufen nicht hinterher kommen, wenn man halt Software hat, die einfach irgendwie das alles wegkriegt.

01:22:01.400 --> 01:22:03.400
Einfach so ohne Grund.

01:22:03.400 --> 01:22:16.400
Jedenfalls genau, also aber wenn man das sich lange nicht angeguckt hat, weil man immer dachte, ah das ist alles furchtbar, vielleicht nochmal hingucken, ist ganz interessant, was da so passiert. Also ich meine, ist auch so ein bisschen ärgerlich, aber auf der anderen Seite auch faszinierend, was da alles so geht.

01:22:16.400 --> 01:22:19.400
Genau, tja.

01:22:19.400 --> 01:22:21.400
Ja, vielleicht muss ich doch irgendwann.

01:22:21.400 --> 01:22:22.400
Das war jetzt aber schon ein sehr spezieller Pick, Jochen.

01:22:22.400 --> 01:22:24.400
Ja, war sehr speziell.

01:22:24.400 --> 01:22:30.400
Nochmal, was wir bei Foxhot oder sowas machen, wenn wir hier die ganze Zeit nur so Mediensachen tun wie mit den Bildern.

01:22:30.400 --> 01:22:34.400
Wir sind ja in so einem Mediumdings hier auch.

01:22:34.400 --> 01:22:36.400
Ja.

01:22:36.400 --> 01:22:40.400
So Musik, ja die Musik, die ich mache, die finde ich meist sowieso abartig.

01:22:40.400 --> 01:22:47.400
Ja, ich glaube, dann sind wir für diese Episode tatsächlich ausnahmsweise mal früh fertig.

01:22:47.400 --> 01:22:59.400
Ich habe übrigens tatsächlich zwischendurch Kritik bekommen auf YouTube, heißen von Leuten, die den Podcast hören, die meinen, es wäre viel zu lang, es wäre total nervig, man könnte es gar nicht mal zwischendurch hören, sondern müsste eigentlich immer so viel Zeit von dem, man kommt da gar nicht durch, man hört sich nie zu Ende.

01:22:59.400 --> 01:23:01.400
Ja, da muss man ein bisschen.

01:23:01.400 --> 01:23:07.400
Also alles, was Sie an weiterer Kritik, Anregung fragen und so weiter, hallo@pythonpodcast.de.

01:23:07.400 --> 01:23:10.400
Bleibt uns gewogen, hört uns weiter. Danke, Johannes, dass du wieder da warst.

01:23:10.400 --> 01:23:13.400
Das nächste Mal gerne wieder vor Ort, du weißt, das war eine.

01:23:13.400 --> 01:23:16.400
Ich komme jedes Mal gerne vorbei, wenn ich da bin.

01:23:16.400 --> 01:23:18.400
Ja, wir freuen uns wieder drauf.

01:23:18.400 --> 01:23:21.400
Ja, danke Jochen und wir hören uns bald wieder.

01:23:21.400 --> 01:23:22.400
Bis dann.

01:23:22.400 --> 01:23:23.400
Bis dann, tschüss.

