Ja, hallo, liebe Hörerinnen und Hörer, willkommen beim Python-Podcast, Episode 58.
Wow, 58.
Ja, gar nicht so schlecht, oder?
Über was reden wir heute? Über Fluent Python. Hi, Jochen.
Jo, hallihallo, Dominik. Herzlich willkommen.
Und hi, Johannes.
Johannes, hi.
Schön, dass du da bist.
Ja, schön, dass ich wieder da sein darf.
Wir hatten dich ja schon ein paar Mal hier, habe ich gehört.
Ich war schon, ich glaube, ein- oder zweimal oder so ungefähr dabei, ja.
Ja, glaube ich auch. Anderthalb oder so.
Wir wollen heute über ein Buch sprechen, Fluent Python, von Luciano Ramalho.
Richtig ausgesprochen? Ich weiß nicht, genau.
Ja, oder das haben wir uns so ein bisschen als Vorlage hergenommen.
Ich würde eher denken, wir, also, es wurde, es wurde, wir hatten,
Warum sprechen wir denn über ein Buch?
Uns erreichten, genau, uns erreichten irgendwie Zuschriften, die sagten,
ah, mach doch mal ein bisschen was mehr für Anfänger und irgendwie mehr.
Und dann hast du dir das tollste Buch ausgedrückt, wo du dann.
Mein, mein, mein, tatsächlich mein Lieblings, Lieblings-Python-Buch.
Und dann dachte ich, ah ja, da kann man ja vielleicht mal so ein bisschen durchgehen.
Ja.
Dass da so die.
Ich lese mal kurz aus dem Buch vor, weil du sagtest ja, du bist ein Anfänger.
Ja, aber ein Anfänger, ja.
If you are just learning Python, this book is going to be hard to follow.
Not only that, if you read it too early in your Python,
it may give you the best and every Python-Scription-level-special-message
and metaprogramming-tricks und so weiter.
Also, da steht für alle Leute, die es nicht verstanden haben,
es ist kein Anfängerbuch.
Ja, ja, gut, aber wir machen ja jetzt nicht Metaprogramming.
Also, Metaprogramming-Zeugs ist da auch drin,
aber das machen wir ja jetzt gar nicht, noch nicht.
Okay, dann steigen wir leicht ein mit Datenstrukturen und sowas.
Genau, wir fangen jetzt mit so ganz grundlegenden Dingen dann an.
Nicht, dass wir Struktur hätten in dieser Folge, aber wir versuchen es heute.
Ja, so ein bisschen.
Also, wir hatten ja auch schon mal was zu Dicts gemacht und zu Listen.
Ja.
Ich weiß nicht, ob wir schon Strings hatten.
Hatten wir, glaube ich, noch nicht.
Also, wir haben darüber schon öfter gesprochen,
aber ich glaube, wir haben tatsächlich noch keine Folge dazu gemacht.
Steht noch auf unserer Möchten-wir-gerne-machen-Liste.
Aber vielleicht jetzt noch mal zu News.
Gibt es denn was Neues in Python, in der Python-Community?
Ja, also, seitdem wir das letzte Mal aufgenommen haben,
ist nicht so wahnsinnig viel passiert.
Ist jetzt auch gar nicht mehr her.
Letzte Woche war YouTube.
Euro-Python, Jürgen.
Ach ja, ja, Euro-Python.
Wie war denn die Euro-Python?
War gut, hat Spaß gemacht.
Ja, war cool.
Hat sehr viel nette Leute kennengelernt und mit ihnen geschnackt,
wie das halt so ist.
Ich weiß aber nicht, ob das einen News-Charakter hat.
Also, außer mich persönlich natürlich.
Was ich sehr genossen habe, war tatsächlich Luca Schlanger
und der Python-Rapple-3.13-Talk,
der quasi der letzte war vor der Abschlussrede,
wo man so ein bisschen interaktive Möglichkeiten sehen konnte
von dem, was so möglich ist.
Es war so ein bisschen eine Mischung aus iPython
mit Python.
Und man konnte richtig coole Sachen machen
und Bindings und Fancy-Stuff.
Ist so ein bisschen ein Spaß-Talk gewesen.
Also, er hat dabei Musik gemacht,
hat Euro-Rack angeschlossen
und seine MIDI-Synthesizer damit bedient.
Also, genau war mein Ding.
Ja.
Fanden die Talks raus und schaut doch mal rein.
Ist mit Sicherheit sehr nett.
Und was ich auch ganz gut fand,
war, wir haben alle relativ viel darüber diskutiert,
was Armin Ronacher so erzählt hat zu,
was scheiße läuft in Python,
und zwar das ganze Packaging-Ding und so.
Ja.
Das wissen, sind wir ja wahrscheinlich
alle derselben Meinung.
Dass es da irgendwann mal so ein Tool geben könnte,
das sowas macht wie vielleicht Cargo für Rust oder so.
Ja, nein, der Meinung bin ich aber nicht.
Also, ich bin der Meinung,
dass es schön wäre, wenn wir sowas hätten.
Aber ich glaube, ich fürchte,
dass wir sowas nicht kriegen können.
Okay, aber das ist ja was anderes.
Aber da gibt es auch schon 23 Tools,
die sowas machen.
Ja, genau.
Armin meinte auch,
da gibt es halt noch ein 24.
Das ist jetzt.
Aber das ist so,
das ist der alte XKCD-Comic.
Aber das ist so ein bisschen,
vielleicht doch.
Also, vielleicht sollte man einfach miteinander reden
und vielleicht doch so ein Ding,
bauen, was dann übrig bleibt.
Weil man braucht halt was,
was diese ganze Quark-Sache,
wie Pakete managen und PIP-Tools
und PyEnv und Conda
und, und, und, und, und, und, und.
Irgendwie so schön nutzbar macht,
dass irgendjemand,
der das noch alles nicht kennt,
einfach mal so ein Curl macht
auf so eine Installation
und dann hat der ein Tool,
mit dem das alles geht.
Das wäre schon ziemlich gut.
Also, so vom.
Ja.
Vom Paint-Faktor her.
Und immer dann,
wenn ich jetzt Leuten versucht habe,
das beizubringen,
oder versucht habe,
bei denen Python zu installieren,
oder auf so einer Schulung
irgendwie kleine Sachen
mit denen machen wollte,
oder die zum ersten Mal
so ein Notebook in die Hand nehmen wollten,
oder irgendwie irgendwas anderes,
das war immer Schmerzen damit verbunden.
Ja.
Und da ja Rust gerade so.
Nein, eigentlich ist das ganz einfach.
Also, du musst folgende Sachen installieren.
Das ist wirklich nur eine sehr kurze Liste.
Ja, ja.
Also, erst mal brauchst du Build Essentials
und dann brauchst du die ganzen Abhängigkeiten
und LibJPG und LibJPG 98
und LibJPG 2K.
Und dann musst du Pyra installieren
und dann bist du schon fast so weit.
Und dann Apfel und eine Banane
und wie Jochen sagt,
den ganzen Dschungel.
Und ja.
Also, ich habe am.
Das ist wirklich sehr.
Der RealPython am Sprint
und für Pyra und so ein paar Sachen installiert,
weil ich es kompilieren wollte.
Es hat tatsächlich drei Stunden gedauert,
bis ich es kompiliert habe
auf meinem Tunnel.
Klasse.
Ja.
Aber so ist das manchmal.
Ja.
Ja, also, ja, ich bin mal gespannt.
Also, ich bin da.
Also, ich habe ja auch schon dann irgendwie gehört,
was Leute dazu sagen,
die sich mit diesem ganzen Thema
schon lange beschäftigen.
Und es gab auch schon mehrere,
Versuche, das zu vereinheitlichen
und da auch Peps zu etablieren,
die quasi das standardisieren.
Und die sind gescheitert alle bisher.
Auch das letzte Mal,
als jetzt der,
wie heißt er jetzt noch?
Einer ganz bekannter,
einer der bekanntesten
Python-Core-Entwickler,
der halt auch da irgendwie
so ein großes Team
bei Microsoft leitet.
Der große Kanadier,
wie heißt er noch?
Ich habe den Namen vergessen.
Keine Ahnung.
Auf jeden Fall,
der hat da versucht,
einen Peps zu gemacht.
Das ist halt hinterher gescheitert,
weil, ja, also mit dem Fazit,
es geht nicht.
Armin meinte,
es braucht vielleicht noch ein Jahr,
dann sind viele
der Grundvoraussetzungen geschaffen,
die da noch fehlen
und das wären gar nicht mehr so viele.
Okay, ich bin gespannt.
Also, wenn das dann funktioniert,
dann lasse ich mich überzeugen.
Aber das, ja, gut.
Werden wir dann sehen.
Was auch interessant ist,
es gibt einmal diese UV-Geschichte,
da gibt es dann auch noch
diese Firma von Charlie Marsh,
die hat ja das irgendwie übernommen,
das zu maintainen, das UV.
Ja, genau.
Ja, also UV und RAI,
was war von einem?
Quatsch, genau,
der hat nicht UV übernommen,
sondern RAI, sondern genau.
Die integrieren sich tatsächlich
relativ,
die reden auch voneinander
und übereinander und so
und die integrieren einander
relativ viel
und RAI benutzt das UV
statt PIP-Tools, glaube ich,
oder so, ne,
dann darüber,
das sieht alles gar nicht
so schlecht aus
und die Firma ist, glaube ich,
Astral oder so
und die machen ja auch RUF
und das,
was eigentlich auch relativ gut
funktioniert, finde ich.
Ja, ja, die machen so
eben ganz viel um RUF.
Gibt es auch eine Firma hier,
also es gibt ja da irgendwie
auch eine schnellere Alternative
zu Conda, Mamba,
von PrefixDev
oder weiß ich nicht,
Wolf,
Volbrecht
oder so,
den könnten wir vielleicht
auch mal,
den könnten wir
über diesen Thema fragen.
Ja, du weißt ja gerade,
dass du für dich zuhörst.
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 mal gespannt.
Ja, und ich finde es auch gut,
dass man tatsächlich jetzt
echt irgendwann durch ist
mit diesem ganzen Snarf
und vielleicht also Standards,
also ich mag ja zum Beispiel
diesen Go nicht,
weil zu viel Standard und so,
das ist immer zu viel Opinion
und so und dann, okay,
dann nutzt man dann doch Black,
aber vielleicht gibt es
also ein paar.
Moment, das habe ich nicht verstanden,
was nützt du nicht?
Also ich mag Standards nicht,
also ich mag es eigentlich nicht,
wenn irgendjemand sagt,
wie es sein muss,
wenn jemand so opinionated ist
und sagt, wir machen jetzt,
keine Ahnung,
Tabs instead of Spaces,
weil ich will das so,
wenn ich das anders möchte
und das nervt mich immer so ein bisschen,
weil das ist das Schöne an Python,
es ist halt dynamisch,
ich kann es nicht aussuchen,
wie ich es mache.
Ja, aber gut,
also ich meine,
aber würdest du das,
sozusagen würdest du,
du würdest aber nur
das konfigurieren wollen,
wie es aussieht,
aber du würdest schon
ein Auto formaten wollen?
Ja.
Ja, okay, ja gut,
kann man machen, wie man will.
Ja, also ich meine,
aber wenn man jetzt bei Black
dann irgendwie eine Konfigurationsdatei
jedes Mal mit schieben muss,
das ist halt auch irgendwie
ad absurdum, ne?
Ja, genau, weil Black gibt es
das halt nicht, genau,
dann muss man halt das andere sehen,
aber es gibt ja auch noch andere.
Das ist so eine Sache,
die denke ich mir schon lange,
dass eigentlich diese ganze
Code-Formatting-Debatte,
die ist doch Quatsch, oder?
Ja.
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.
Ja, genau.
Und wenn du die Sachen
in grün oder gelb haben willst
oder in Dateien
oder Modulen aufgeteilt
oder wie auch immer
du es haben willst,
da gibt es so viele Sachen,
die man auf der Ebene
machen könnte,
aber stattdessen haben wir
Textdateien.
Ja, so ein bisschen so,
da müsste man
jemandem was machen.
Da kommt dann immer der Einwand,
dann mach doch mal was dagegen
und dann sage ich,
nee.
Das Problem ist halt,
wie kriegst du denn
aus dem AST wieder was,
wenn du jetzt tatsächlich
was manuell anders haben willst?
Also du möchtest
deine VR-Brille aufziehen
und dann hast du vor dir
den einen Balken,
den einen Graphen
und hast die Nodes,
musst du eine durchmaschinen,
kannst du dich auf dein Laufband
stellen und hinlaufen?
Nee, also da gibt es bestimmt
Leute, die das so wollen,
aber ich will ja nicht laufen,
ich bin ja ein Softwareentwickler.
Aber ob du jetzt
Tabs oder Spaces hast
oder ob du die Variablen
so oder so nennst
oder ob du, keine Ahnung,
viele Dinge, die du da,
ob du Einrückungen
oder Braces haben willst,
das ist doch auch völlig egal.
Wenn Leute lieber
Braces haben wollen,
dann sollen sie halt
sich ihren Editor so einstellen,
dass der die Blöcke
mit Braces umfasst.
Und umgekehrt,
wenn ich TypeScript schreibe
oder so,
dann will ich dann nicht
überall Braces haben.
Dann muss doch mein Editor,
muss doch smart genug sein,
das umformen zu können.
Und warum ist das so schwierig?
Ja, also ein Grund,
der mir jetzt sofort...
Das ist so eine Debatte,
die jetzt auch ins Gebüsch führt.
Ja, also ein Grund,
der mir direkt so einfallen würde,
ist halt, was ist,
weil das hatte ich jetzt
letztens wieder,
ist halt, was ist,
wenn ich Dinge anders machen möchte
als jeder andere?
Du meinst Innovation?
Nein, einfach optisch.
Müll.
Ach so, Entschuldigung.
Ja, das muss doch
dein Editor können.
Das muss doch eine
Einstellungssache bei dir sein.
Weil am Ende kommt
der gleiche Python,
der weiß den Code raus.
Ja, aber wenn jetzt sozusagen,
du kriegst jetzt Code
von jemand anders.
Wie soll denn das,
so wie ich das sehen will,
wie soll der denn
dahin transformiert werden?
Das kannst du nur
im Sprachmodell machen.
In der Standardform geht leicht,
aber der umgekehrte Weg
geht halt nicht.
Oder?
Über den Sprachmodell.
Ich glaube, das geht
in alle Richtungen.
Aber das wäre halt das,
was da zu beweisen wäre.
Und ich glaube,
dass die richtige Darstellungsart
eben nicht Text
in ASCII oder Unicode ist,
sondern halt
ein strukturierteres Modell.
Und aus diesem
strukturierteren Modell
kannst du dann ja mehr Sachen
auch rausziehen.
Ja, gut.
Aber es ist unbewiesen.
Ja, das ist hier so ein,
wie gesagt,
so ein Jemand-sollte-das-mal-tun-Projekt.
Ja.
In meiner vierstelligen Liste
der Nebenprojekte
ist es nicht auf Platz 1.
Also jedenfalls,
ich wollte eigentlich
für Standards
an der Stelle sprechen,
weil ich tatsächlich finde,
dass das so ein bisschen
anstrengend ist.
Und es wäre schon gut,
wenn so ein Standard
das so löst,
dass diese ganzen
Pains und Probleme
eine Lösung haben,
die tatsächlich von allen
so mitgetragen wird.
Das wäre schon irgendwie
nice to have.
Also so ein
Cholera-Boutive-Spiel,
äh, Cholo,
boah,
Zungenbrecher.
Ihr wisst, was ich meine.
Ein Cholera-Spiel?
Ja.
Aber du meinst jetzt
für Code-Format?
Nein.
Ach so, okay.
Ich meine für Packaging.
Packaging.
Und also Installation
und Python generell
und Binarys verteilen
und Setup
und VENVs
und Dependencies
und,
und sowas alles.
Naja, ich habe mir halt
diese Diskussion
halt so ein bisschen angeguckt
und die hinter,
hat mich so ein bisschen
hoffnungslos
zurückgelassen,
weil,
also auch die Leute,
die sich damit beschäftigt haben,
die sind ja,
haben das ja auch,
das sei ja das Ziel
und das Ergebnis war,
geht nicht.
Ja, das Problem ist halt,
man will sich aber
damit gar nicht beschäftigen.
Doch, doch,
da haben sich,
oh yeah,
da haben sich viele Leute
ganz lange mit beschäftigt.
Ich möchte mich nicht
damit beschäftigen,
was für Problem-Python
beim Packaging installieren
beim VENV hat,
sondern ich möchte
Packages installieren,
die die benutzen.
Ja, aber,
weil ich möchte halt
Programme schreiben.
Ja, aber die Frage ist,
ist das überhaupt möglich
bei einer so alten Sprache?
Geht das?
Und bei Rust,
also die Antwort ist,
warum geht das bei Rust,
ist halt,
die Antwort darauf ist halt,
das geht deswegen,
weil das eine sehr junge Sprache ist
und weil man all die Dinge,
die man früher bei Python macht,
hat da halt nicht drin.
Ja, aber da müssen wir
auftärmen,
das sind also,
so jung ist Rust nicht.
Ja, aber das Problem ist,
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.
Und dann,
Johann, was würdest du sagen,
wann ist Rust erschienen?
Wann war das erste Release
von Rust?
Ich glaube,
das ist etwas mehr
als 10 Jahre her.
Also irgendwann 2013,
2015?
15. Mai 2015,
also 9 Jahre.
Ah, gut.
Nicht so schlecht.
Habe ich sogar ein bisschen
zu alt geschätzt, ja.
Ja, okay,
aber also ganz junge Sprache
ist es auch nicht mehr.
Nee, aber viel, viel jünger
als Python,
viel, viel jünger.
Ja, gut,
das stimmt natürlich.
Wobei Python 3
ist jetzt auch noch nicht,
ist doch auch erst
seit ein paar Jahren.
Ja.
Ich sage ja,
wir zeigen Python 4.
Okay, ja.
Die nächste Version
ist Python 8, oder?
Da gab es doch mal
so einen April-Scherz.
So ein Pep,
wie die nächste Python-Version
heißen sollte
und dass man dann
immer additiv vorgeht.
Der große Vorteil
von dem Versionsschema
ist, dass man
alle anderen Versionen
einholt.
Das war auch ein lustiger Talk.
Wer ist nochmal
der Release-Manager
von 13 und 14?
Wisst ihr?
Thomas Waters?
Kann er auf jeden Fall,
ja.
Ich meine,
der war auch lustig,
weil er meinte nämlich,
er möchte gerne
das Versioning
von Python ändern,
einfach auf Jahreszahlen
anpassen.
Dann wäre es halt
demnächst Python 24
einfach,
dann Python 25.
Und dann aber
mit drei davon,
wenn wir drei behalten,
dann 325,
weil Semantik-Version
irgendwie Blut wäre.
Dann müssen sie sich
aber auch noch
irgendwelche lustigen
Tiernamen ausdenken,
die da dazu passen.
Ja.
Und bitte
alphabetisch aufsteigend.
Ja, genau,
so ungefähr.
Ja, das war dann
die Debatte.
Ja, also ich meine,
es gab viel Spaß
und die Talks sind
sicher auch irgendwann bald da
und die kann man sich
alle angucken
gucken.
Es gab ja
verschiedene Tracks,
der Data-Track war
relativ viel vertreten
wieder.
LLMs und so
sind ja wie immer
hoch dabei.
Ich hatte nicht
das große Glück,
dass ich jetzt da
so einen Talk erwischt
hatte, der mich
so total faszinierte.
Die waren immer sehr,
ich sag mal,
High-Level,
was jetzt auch
nicht schlecht sein muss.
Aber ja,
bis auf so ein paar Sachen,
die halt darum gingen,
so wie man das vielleicht
mit dem Trainieren
noch ein bisschen
besser hinkriegt
oder mit dem Feintunen,
dass man ein bisschen
effektiver sein kann
und nicht so viel
Speicher dafür braucht
oder so.
Aber das müssten wir uns
eigentlich mal für eigene
Episoden irgendwann aufheben.
Sowas.
Ja.
Was für News
haben wir noch, Jochen?
Ah ja,
jetzt wo es um
Euro-Python ging,
was mir eingefallen ist,
stimmt,
wir hatten ja
letztes Mal auch
über die DjangoCon
Europe 2024 geredet
und die Vorträge
sind jetzt online.
Ja.
Können Sie sich angucken
und da bin ich jetzt
gerade dran,
die so ein bisschen
nach und nach anzugucken,
die ich interessant finde.
Und da habe ich auch
schon interessante gesehen.
Da war auch jetzt
diese Woche
ein Treffen
der Pythons
User Group,
Django Cologne
User Group,
wo es dann halt
auch einen Vortrag gab
über Background Tasks,
was ganz interessant war.
Genau.
Und ja,
das klingt alles
tatsächlich ziemlich interessant.
Also da haben sich schon
Gedanken über das Interface
gemacht.
Salary ID.
Ja, könnte sein,
was eine gute Sache wäre.
Ja, und es wäre richtig gut.
Ja, aber
da wollte ich noch sagen,
weil du gesagt hast,
die ganzen Talks gucken,
das war tatsächlich auch super.
Ich mag dieses
hybride Format
von Konferenzen.
Auch bei der Europe Heist
konnte man halt,
weil abends,
wenn man ganz
schon durch war
von dem ganzen Tag
und die ganzen Konferenzen
live gesehen hat,
sich nochmal den Track
von den Sachen,
die man verpasst hatte,
bei YouTube auf anderthalbfach
angucken zum Einschlafen
oder zum Runterkommen.
Ja, das war sehr cool.
Das heißt,
man kann alle Sachen
parallel gucken gleichzeitig
oder länger frühstücken,
wenn man mag.
Was echt schön ist.
Sehr zu empfehlen.
Ja, ansonsten
so in Ermangelung
von Dingen,
die jetzt mit Pythons
so viel zu tun haben,
was mich hier gerade
so noch so ein bisschen
umtreibt,
ist halt,
ach ja,
es war bald Urlaub
und ich habe ein bisschen
neue Hardware
irgendwie mir zugelegt.
Jochen,
das ist keine Werbeveranstaltung
hier.
Nee, aber
was ganz cool ist,
es gibt jetzt so ein,
tatsächlich,
also dieser Haushalt
enthält Computer,
kann Spuren von Computern
enthalten
und der schnellste Computer
in diesem Haushalt
ist jetzt ein iPad.
Und ja,
also da sind ja
diese M4-Dinger drin,
die sind sackschnell.
Also es ist unglaublich
schnell.
Also lässt du das jetzt
deine Machine Learning-Modelle
tunen?
Aber das ist doch kein
General-Purpose-Computer.
Nee, leider nicht.
Argumentiert,
dass es kein
General-Purpose-Computer ist.
Ja, das ist blöd,
aber es wäre voll cool,
wenn es ein
General-Purpose-Computer wäre,
weil es wäre nämlich
der schnellste,
den ich hätte.
Bau doch einfach
die CPU aus.
Ja.
Kannst nicht
Wanders einlöten.
Nee.
Genau, also ja,
das ist so ein bisschen
so,
aber das Ding ist tatsächlich,
also es gibt das,
M4 gibt es auch noch
in keinem anderen Gerät
irgendwie von Apple,
also nur im iPad.
Ja, es ist schon
so ein bisschen traurig.
Es gab auch eine Tastatur
diesmal mit einer
Escape-Taste,
sodass halt irgendwie
mit der Escape-Taste
kannst du eigentlich
auf iOS überhaupt
gar nichts anfangen,
sodass halt viele Leute
gedacht haben,
es kommt irgendwann
ein Mac OS für iPad,
was auch voll cool wäre,
aber nein,
kam nicht.
Und ja,
jetzt habe ich ein iPad
und kann es nicht benutzen.
Ein bisschen doof,
aber ja,
ansonsten wirklich
sehr schnell.
Du darfst ja schnell
YouTube gucken.
Ja, genau.
Und gut, genau.
Ich habe noch so eine
Platine mitgebracht,
die kann man sich
ankleben und
mit so einem Magneten
und da kann man
so einen Text hin und her
laufen lassen.
Und da gibt es
so ein Python-Modul,
da kann man dann
den Text auswählen.
Und das ist
dein schnellster Computer?
Ja, genau.
Und ja,
ansonsten gab es
noch so ein bisschen
irgendwie,
ja,
LLM-Krams.
Ja, da gibt es
doch immer was,
oder?
Ja, also
SAPIC hat tolle neue Modelle
rausgebracht,
die ziemlich beeindruckend sind.
Ja, und Mistral
hat jetzt,
ich glaube,
heute ein neues Modell
rausgebracht.
Nemo heißt das,
mit einem neuen Embedding.
Die haben einen neuen
Embedder trainiert,
der wohl deutlich besser ist.
Das müsste man sich
mal anschauen.
Und dieses Nemo-Modell
hört sich auch interessant an.
Da ist Zusammenarbeit
mit Nvidia entstanden.
Das ist ein 12B-Modell.
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.
Also auf einer
40, 90...
Ja, die haben ja alle
11, 12 Gigabyte
Hauptspeicher, ja.
Genau.
Und das ist wohl auch
schon so trainiert,
dass es mit FP8 geht,
ohne Leistungsabfall.
Und das ist natürlich
direkt sehr praktisch.
Ja, ich habe auch
letztens gesehen,
dass irgendjemand quasi,
also war das
Microsoft Research?
Ich weiß es nicht.
Ich hatte ein Paper
veröffentlicht zu einem
Modell,
dass die gleiche
Performance irgendwie
überführt wird.
Viele unterschiedliche,
oder sogar deutlich
bessere Performance
über viele unterschiedliche
Benchmarks hingekriegt hat
als GPT-3.5,
aber auf einer
einzelnen GPU läuft.
Also auf so einer
Consumer-GPU.
Und das war auch
zum ersten Mal,
dass das jemand
geschafft hat,
quasi GPT-3.5
auf irgendwie
so Consumer-Hardware
zu schlagen.
Und das auch
selber ein...
Also das geht jetzt,
du kannst da wirklich
auf deinem Rechner zu Hause
irgendwie Sachen
laufen lassen,
lokal,
auf deiner
Spielegrafikkarte,
die halt irgendwie
das,
das Chat-GPT
von,
vom Anfang halt
deutlich schlagen.
Und das ist interessant.
Also,
ja,
es geht dran.
Ja,
da tun sich doch
viele Dinge.
Das ist schön,
dass da so,
auch so,
auch so völlig,
sag ich mal,
normale Sachen,
ja,
dass sich jetzt hier
GPT-4 und 4.0
und so,
dass die sich
weiterentwickeln
und Cloud Sonnet
und so weiter.
Ach so,
und das
Mistral-Nemo-Modell
hat ein 128K
Contacts-Window.
Das ist eine
Besonderheit.
Das ist auch
was Interessantes,
weil die anderen
lokalen Modelle
hatten ja immer nur
irgendwie 4K
oder 8K.
Ja.
Und das,
das macht doch
nochmal deutlich
eine Schicht aus.
Dass sich so,
so ganz normale
Sachen,
sag ich mal,
weiterentwickeln,
dass man eben,
genau wie du sagst,
Jochen,
das jetzt auf
normalen GPUs
laufen lassen kann
und dass die Modelle
größer und schneller
und trotzdem
skalierbar werden
und dass,
dass es auch
in der Richtung
Entwicklung gibt,
das finde ich
eigentlich ziemlich cool.
Ja.
Dass es nicht nur so
eben in diesen,
in diesen Hochburgen
und in den
Diensteanbietern
festhängt,
sondern die Szene
ist auch sehr lokal.
Und wenn man sich
da mal so dieses,
wenn man sich
Hugging Face anguckt,
ja,
und wie viele
Pflege von Lama es gibt
und dann gibt es
manche,
wo die,
wo das
Sicherheitstraining
weg ist
und der Einzel
spricht nur
keine Art und Sprache
und der Einzel
ist nur
mit diesem,
das und jenes
kann.
Ja.
Es ist schon schön,
dass da was passiert.
Ja, genau.
Ja, und die,
die andere Seite,
also OpenAI und so,
das ist auch interessant.
Also überhaupt,
da, da,
da wollte ich auch noch
wegen Apple irgendwie
drauf zu sprechen kommen, die
bauen ja jetzt dann irgendwie die Dinger ein
in
iOS und
was eingebaut wird, ist auch
GPT-4.0.
Also du kriegst halt jetzt, wenn du ein iPhone
oder sonst irgendwas kaufst, wahrscheinlich dann ab jetzt,
wenn die neuen Geräte kommen, kriegst du halt
oder eine neue iOS-Version, kriegst du
halt quasi die Bezahl-Version
von OpenAI
irgendwie in deinem Gerät
und
das ist halt ein relativ dicker
Deal wohl und dafür
kriegst, also das ist glaube ich nur ein Gerücht, das ist
noch nicht bescheidigt, aber. Er hat noch sogar einen
Board-Seed. Ja genau, die haben jetzt
Microsoft hat doch die Daten von allen
iOS-Muttern. Haben sie wieder aufgegeben, sind nicht
mehr.
Sowohl Microsoft als auch Apple
haben ihren Board-Seed aufgegeben. Es waren eh nur Beobachtende,
aber haben sie beide, es haben sich beide zurückgezogen.
Achso, okay, ich dachte
eigentlich, dass jetzt
sozusagen das Gerücht war, dass das Phil Schiller
irgendwie ins Board von OpenAI geht, aber
Ja, haben sie aber wieder
zurückgezogen. Ah, okay, dann, naja,
dann war ich halt schon nicht mehr so aktuell,
aber ich meine. Ja, es bewegt sich so
schnell, dass du nicht
Wahnsinn. Wenn man hinguckt, ist schon alles ganz
anders. Aber, naja,
gut, also ich, in gewisser Weise verstehe ich es ja auch, also
das große Problem von OpenAI ist ja irgendwie,
dass sie halt zwar irgendwie ganz
gute Modelle haben, aber sie haben halt
die Geräte nicht da draußen. Also sie haben halt
einen strukturellen Nachteil gegenüber sowas wie Google
oder so. Google braucht das alles nicht. Die können
einfach irgendwie über Android
haben sie da halt einen riesen Hebel.
Und, aber OpenAI,
wenn sie halt nicht Partnerschaften
mit Microsoft oder mit Apple
haben, dann haben sie halt ein Problem, 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. Ja,
insofern, ja, ist auf jeden Fall
interessante Zeiten. Bin mal gespannt.
Aber 4.0 ist auch so gut, also
ich finde das hier auch dauernd, also
dass das wahrscheinlich irgendwie
Was machst du denn damit? Ja, programmieren.
Ach so, ja, gut,
okay, das, ich weiß nicht, das geht nicht in den
Flow rein. Ja,
aber auch Opus, das ist schon
Ja, Opus ist auch super, also ja, absolut.
Oder so nicht. Ja, du gibst
halt einfach so Fragen und das stimmt
dann auf einmal doch eher mehr
als früher. Noch mehr
als früher. Und dann, man kann es
halt so steuern, ne? Habt ihr das irgendwo
integriert oder? Ja, ja, ID.
Also auch Konsole halt,
ne? Und wenn man halt,
dann kannst du halt auch pipen, mit Cut reinpipen
irgendwas oder sag dann halt,
äh, Template, äh,
mach einen PyTest drauf oder so.
Und das ist gut. Gute Vorschläge.
Also die sind nicht immer ganz rein, aber man
kann das ja auch modifizieren, kann sagen, so, ja, ein bisschen mehr
in, ne, ein bisschen mehr Fixtures, ein bisschen weniger
dies, ein bisschen weniger das, wenn man das nicht schon im System
prompt eh schon drin stehen hat. Und dann ist das
ziemlich das, was man will. Man kann ja auch so ein Beispiel
geben, wie, hey, und so wie ich das hier gemacht hab,
so, dass es ungefähr so sollte, könnte es
aussehen. Und dann
fertig.
Ich bin ja mal neidisch, wenn da Leute
das so erzählen, weil ich komm mit,
mit solchen Systemen einfach irgendwie nicht in den,
ich komm nicht in den Flow.
Vielleicht muss man sich da mal zusammensetzen.
An E-Mails, Johannes.
Ich hab doch Peitscham, bin doch
Peitscham-Unterstützer.
Ja, aber
hast du da den, den Copilot zum Beispiel an
oder so? Weil das ist auch schon ganz okay. Also
ich find, ehrlich gesagt, das ist nicht so gut, wie wenn man
jetzt quasi direkt mit, ähm.
Wann hast du das letzte Mal probiert, Johan?
Keins, keins dieser Systeme
hat mich je überzeugt.
Okay. Hab's, hab's ein paar Mal probiert und das war,
jedes Mal so, ne.
Johannes hätte es besser gewusst.
Das, vielleicht ist das Problem, vielleicht
weiß ich es einfach besser. Ja, ich würd's auch sagen.
Ja gut, kann man. Da würd ich aber sagen, dass das
genau das. Ne, wenn der Jochen sagt,
dass das bei ihm hilft, dann kann das
bei mir nicht sein, dass ich es besser weiß.
Also hier ist eine wundervolle, wundervolle
Überleitung jetzt übrigens, weil Tim Peters, der
äh, Co-Entwickler und
Autor von Zen auf Python, das ihr bestimmt alle kennt, ne,
im Prozess, äh, dann meinte
der Plan wäre, wenn jemand ein Feature entwickelt,
das du nicht verstehst, dann knall ihn einfach ab.
Ja. Und das ist der Einstieg
in das wunderschöne Buch von
Python. Ja, muss man direkt mal klar machen, wie
die Sachen dann so laufen und, äh, genau.
Das ist auf jeden Fall einfacher, als etwas Neues zu lernen.
Ja, und dann am Schluss hat man nur noch Leute, die
irgendwie kein Problem mehr haben, das zu verstehen, was man sagt.
Und, ja, und bevor, äh, die einzelnen
lebenden, überlebenden Entwickler, dann
ja, kann man ein
kleines Stück von dem, was man schon tun kann,
dann verwenden und kommt damit irgendwie weiter.
Also sind wir jetzt bei Flut und Python?
Sind wir jetzt bei Flut und Python?
Sind die News, äh, ja, ich würde tatsächlich,
tatsächlich jetzt so ein bisschen unser
Quatsch versuchen, in eine Struktur
zu überführen, die uns ein bisschen zurückführt auf
dieses wundervolle
Python-Data. Also ich, Flut und,
was heißt denn Flut und Flüssig? Also ich habe, wollte nicht
über das Buch sprechen eigentlich. Fließend, fließend.
Ich wollte eigentlich, eigentlich wollte ich gar nicht erwähnen,
dass das Buch, äh, das, das, das jetzt
aus dem Buch klaut, aber gut. Ach so, du, du, ach so,
du wolltest einfach so tun, als ist das deine, deine,
Entschuldigung.
Ach so, so gründlich versaut.
Okay. Ja.
Ja, nee, wir können das auch sagen.
Ist ja kein Problem, aber, äh, genau, was wir,
dann können wir es schon abgeben, finde ich, ja. Was es, was es
heute, äh, 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 Referenz
so genannt. Es gibt andere Leute, die nennen das
irgendwie anders, Python-Object-Model oder so.
Und im Grunde geht es darum,
was ist denn das jetzt überhaupt wieder alles?
Genau. Also ich tue jetzt mal einmal so, ne.
Ja, ja.
Tu mal so, als ob du das nicht wüsstest, damit ich. Ja, genau, das sag ich doch.
Ja. Wie immer.
Ähm.
Also zum Beispiel,
ist halt die, die, die, die,
ein super Beispiel ist halt, um da
vielleicht einen Einstieg zu finden, warum sagt man
in Python eigentlich irgendwie len
von irgendwas, irgendeiner Collection oder so
und nicht collection.len
Klammer auf, Klammer zu, wie man das jetzt vielleicht
in Ruby machen würde oder so. Ich weiß ehrlich gesagt
gar nicht, wie man es in Ruby macht, aber
In Java, sehr gerne. In Java, in Java.
Die machen das komisch. Genau.
Warum macht man das eigentlich so? Und, ähm,
ja, also der,
das, was halt, äh,
Python an der Stelle
halt anders macht, ist halt,
dass es irgendwie ein bisschen
objektorientierte Purity sozusagen
irgendwie opfert, um halt eine Menge
andere Vorteile zu kriegen.
Und, ähm, ja, das macht es, also das ist
überhaupt so eine charakteristische Geschichte von, von
Python, dass man halt, ähm,
oft irgendwie, ja, halt nicht
die, die reine Lehre irgendwie macht, sondern
halt irgendwie etwas, was nicht ganz so rein ist,
aber was halt praktisch viel besser funktioniert.
Okay, ich verstehe jetzt meine Sache nicht. Also warum ist erstens irgendwas mit
Klasse und Attribut und Methode
called die reine Lehre und zweitens, was ist das
Problem, wenn man irgendeine Funktion hat oder eine
äh, äh, call it whatever you like
oder eine Closure und kippst da, äh,
ein Objekt rein und dann
passieren Dinge damit? Naja, 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.
Warum? Ja, so ist es halt gedacht.
Also, ja. Das ist zum Beispiel in Java so.
Ja, aber warum ist das so? Java heißt
Kingdom of Nouns und, äh,
äh, es gibt quasi keine
Funktionen in Java, sondern es gibt nur Objekte und
denen kannst du Nachrichten schicken und die machen
dann irgendwas. Und das ist der einzige
Mechanismus, den es im Wesentlichen gibt. Und selbst
wenn du sowas hast wie eine Main-Funktion,
dann hast du da irgendwo eine Klasse und dann ist es halt
eine Static-Methode
auf dieser Klasse drauf. Und
anstatt, dass du sagst, äh,
wenn unser Programm läuft, dann rufen wir die Main-Funktion
auf, sagst du, wir schicken eine
Main-Nachricht an unsere Main-Klasse.
Aber warum
würde man auf die Idee kommen, dass das eine gute
Idee sein könnte?
Naja. Also, was ist
das? Also, ich muss mal kurz über die Trade-Offs reden,
um das mal so zu rütteln. Warum wollte man
denken, dass das eine gute Idee sein könnte, sowas
zu tun? Naja,
es reduziert natürlich schon die Anzahl von
Dingen, die es so gibt.
Es sind halt nur Objekte und Methodenaufrufe und mehr nicht.
Und das ist warum gut?
Also, Simplicity...
Einfach eine Sache lernen.
Weil Einfachheit ein Wegweiser zur Wahrheit ist.
Oder zur Schönheit oder so.
Okay.
Point 1 für den Java-Entwickler.
Für den dir.
Ja. Okay, und
warum ist es denn nicht auch einfach,
einfach sowas wie
funktionale Programmierung zu machen und da
Zeug hintereinander hin und her zu reichen?
Was fehlt einem denn da in diesem Vergleich?
Funktionale Programmierung ist ja auch was anderes.
Das gibt's auch, aber das ist was ganz anderes.
Also, das ist ja...
Also, kann man auch machen. Aber dann...
Also, das wäre... Kannst du auch
Pure haben, sowas wie Haskell oder so,
oder Erlang oder weiß ich nicht.
Ah, Standard-ML.
Ja. Haskell, ja, diese modernen...
Ja.
Aber das ist halt
ein anderes Konzept als jetzt Objektorientierung.
Naja, aber wir sprechen gerade...
Von ästhetischer Einfachheit
oder so. Jaja, ist es auch.
Aber es ist halt anders. Da gibt's halt dann nur
Funktionen, sozusagen. Okay, aber ich wollte
kurz auf die Trade-Offs hinaus, weil...
Warum ist das jetzt...
Naja, also
der Grund, warum man jetzt denken könnte, dass es halt im Halten
nicht so schön ist halt, dass man sagt,
jetzt muss man halt auch noch so... Jetzt haben wir so Build-ins wie
Len oder so, die so ein bisschen komisch sind.
Aber tatsächlich hat es halt
praktisch sehr viele Vorteile, wie
ähm... Naja, ähm...
Also, einmal
du musst dir nicht für jedes Objekt merken,
wie das denn jetzt nun heißt
mit dieser Methode, weil das kann ja jeder dann anders
machen. Das wäre ja irgendwie schlecht.
Sondern... Das ist zum Beispiel ein Problem, was
PHP hat. Ja. Oder JavaScript.
Da heißt es manchmal Size und manchmal Length
und manchmal Count. Ja.
Ja. Und, ähm...
Eine andere Geschichte ist halt, es ermöglicht
dir halt, äh, irgendwie
so ein paar dreckige Optimierungen
zu machen, die halt irgendwie
die Dinge, die wirklich, äh, Zeit
kosten, irgendwie deutlich schneller zu machen. Wie zum Beispiel
äh, du kannst halt
da diese Sachen...
Tatsächlich, was Len halt macht, ist ja
schon dann quasi, wenn das
ein Objekt ist, einer Klasse, die du erstellt hast,
dann wird halt, äh, dann da
Len aufgerufen. Schon doch die Methode,
die geheime... Die Methode aufgerufen.
Mhm. Äh, aber die ist halt
nicht dafür da, dass, ähm, irgendwie
andere die aufrufen, sondern, äh,
oder dass man die von Hand aufruft, ähm,
zu Fuß, äh, oder wie auch immer, sondern die ist
halt dafür da, dass der Interpreter die aufruft.
Wenn man halt Len von
irgendwas sagt. Und dann ruft
der Interpreter die auf, aber der Interpreter kann halt auch andere Dinge tun.
Der kann zum Beispiel jetzt, wenn das ein, ähm,
irgendwie so ein
native, also ein Ding im Interpreter selber ist,
also oder irgendwie ein C
geschriebenes Ding, wie ein Dikt oder eine Liste
oder sowas ist, dann kann es halt direkt,
äh, irgendwie in diesem PyObject irgendwie
drauf gucken, wie lang ist denn dieser, dieses Ding
und gibt es dann halt zurück. Und muss halt keine
Methode aufrufen. Also Methodenaufrufe sind halt
etwas, was halt in Python super langsam ist.
Oder in allen interpretierten
Programmiersprachen, die so ähnlich sind wie Python,
sind halt Funktionsaufrufe, Methodenaufrufe immer
total langsam. Ist halt, da ist
wirklich so ein Faktor tausend dazwischen, zwischen
irgendwie reinem C und
Funktionsaufruf und, äh, und Python
oder so. Und, äh, ja,
für die ganzen
Standardfälle, wo man das halt benutzt,
kann der Interpreter das halt alles
wegoptimieren. Und dann macht er das halt einfach nicht.
Sondern da wird gar nichts aufgerufen.
Ähm, ja. Also das sind halt
zwei große Vorteile, die man halt kriegt,
wenn man halt ein bisschen Reinheit
opfert, sozusagen. Und, ähm,
genau. Das ist halt irgendwie diese Balance zwischen
irgendwie, äh,
Reinheit und, und funktioniert
super. Und Magie. Genau.
Ist halt so eine Spezial... Ja, Magie
mag der, mag jetzt zum Beispiel der Autor
von Flunepython an der Stelle gar nicht so
gerne. Äh, so der, der
also, man, man nennt die Dinger ja irgendwie
äh, äh, Magic Methods auch.
Also dieser, äh, Magic Methods
ähm, äh, die...
Das finde ich eine sehr schöne Diskussion. Ja. Über diese
Namen, über die Magic Methods und über die
Nicht-Magic Methods. Ja, ja.
Fand ich, fand ich auch so. Das kommt halt so aus der
Ruby, Ruby Community. Das wusste ich gar nicht.
Ich dachte eigentlich, das gibt halt ein paar
Python-Entwickler, die nennen das halt Magic Methods.
Die dann sagen halt Dunder Methods oder sowas. Oder...
Ja, aber
in, in der Ruby-Welt ist das wohl
üblich. Und, ähm,
ja, aber der... Das ist der offizielle Name,
oder, in Ruby? Ja, ja. Das, das, die heißen
Magic Methods. Genau.
Ja, oder auch in iPython oder so
heißen die auch irgendwie Magic und dann gibt's diverse...
Aber, aber... Aber das ist ja auch
wirklich Magic. Das ist wirklich Magic? Okay.
Aber eigentlich sind halt eben
die, die Python-Dinger gar nicht Magic, sondern
das ist halt eigentlich völlig klar, das dokumentiert, was das ist
und was das tut. Und, ähm,
insofern, der, der Autor sagt selber, okay,
er findet das nicht gut. Die sollten lieber Muggel,
Muggel-Methoden heißen oder so, weil sie halt
so unmagisch sind. Aber
ja. Ja, er nennt's ja dann auch
auf Special Methods einfach. Special Methods
ist auch ein guter Name. Ich glaube, das, was da,
was da magisch ist, ist, dass man die
implementiert und dann, äh, werden sie
irgendwo her aufgerufen und... Ja.
Wenn er das nicht weiß, dann ist das schon magisch.
Ja, ich glaube auch. Dann gibt's Lenden von irgendwas ein
und es wird aber was ganz anderes. Dass du für Anfänger
es nicht ersichtlich, dass wenn du irgendwie so eine Methode dazu fügst,
die Dinge macht, wo du nicht weißt, warum.
Weil das unter der Haube passiert. Genau.
Und, aber das Spiel war ja auch nicht, also magisch
schon gut. Das macht ja Magie. Ah, es
passiert irgendwas, ne, dann machst du einen String auf
irgendein Objekt und dann kommt da irgendwas raus, weil du eine
Repre-Methode beschriebst und dann, ah, Magie.
Ne, so.
Ja, ja. Wobei das natürlich eine sehr,
eine sehr dünne Schicht Magie ist.
Ja, das, äh, wie der Jochen schon gesagt hat, das, da gibt's
eine Liste, so viel Magie gibt's
und die sieht auch so und so aus und
im Wesentlichen ist das ja nur eine syntaktische
Umformung. Syntaktische Magie.
Damit, syntaktische Magie, genau.
Ja, aber das ist doch quasi echte Magie.
Ich meine, echte Magie, da fummelt jemand
vor den Augen mit deinem
Fingerschnipsen rum und auf einmal zieht der hinterher
seinem Ohr eine große, goldene, glänzende Münze.
Ja, das sind Illusions.
Das ist, das ist keine Magie. Das ist so ein bisschen
aber so eine taktische Magie.
Ja, aber echte Magie ist doch das, was man aus Harry Potter kennt.
Dann schwingst du deinen Zauberstab und dann passiert
irgendwas. Die richtigen Worte, der richtige
Händler. In der richtigen Reihenfolge sagen, genau.
Der macht irgendwas, was thermodynamisch nicht
möglich ist. Ja, genau, aber sind wir uns eigentlich alle
relativ einig, das gibt's halt auch nur in Harry Potter
oder in. Ich weiß nicht, also ich finde
tatsächlich. Und in Ruby. Die Analogie auch gar
nicht so schlecht für Programmieren insgesamt. Also ich meine,
halt, also ich meine, was ist, also man
sagt irgendwie. Du sagst die richtigen Wörter
in der richtigen Reihenfolge und dann passieren
Dinge, genau.
Ja, ich finde, das ist gar nicht so
weit hergeholt, dass man dann das vergleicht. Deshalb sind wir
alle Wizards. Ich hab auch den Wizard-Pullover.
Es gibt auch tatsächlich Leute, die
Nicht-Programmierer als Muggel bezeichnen.
Also ich weiß, so weit würde ich jetzt nicht gehen vielleicht, aber.
Echt, ich bezeichne die mal als NPCs.
Ja. Nein.
Tatsächlich, das
erste Beispiel in einem
nicht näher benannten Buch, was ich kürzlich gelesen
habe,
das hat mich tatsächlich etwas überrascht. Da war
tatsächlich ein bisschen Magie drin. Und zwar,
da wird ein
Card-Deck implementiert.
Ja. Und er implementiert nur
zwei von diesen Methoden. Ja,
für Kartentricks dann.
Und er implementiert nur zwei
Methoden, nämlich dann der Len und dann der Get-Item.
Ja. Und
das reicht aus für Slicing
und Ranges und Wurst und Iteration.
Das hat mich etwas überrascht,
dass der Python-Interpreter sich aus einem
Get-Item, aus einem Len,
kann er sich alles zusammenbasteln. Ich meine, es ist nicht,
wenn man so ein bisschen drüber nachdenkt, ist es
einfach nur smart,
dass das geht. Und es ist auch klar, dass das geht.
Wenn ich weiß, wie viele es sind und ich ein einzelnes
holen kann, dann kann ich
auch mehrere holen. Okay, gut.
Und ich kann auch
Reverse machen drauf. Okay, auch das
ist nicht arg überraschend.
Und ich kann auch Iteration machen drauf. Okay, auch das
ist nicht arg überraschend mehr.
Aber dass es implementiert ist,
das fand ich
sehr cool.
Ja, man delegiert im Grunde
die ganze schlaue
oder die ganze schwierige Funktionalität von
wie das halt so funktioniert an die
interne Liste in der Datenlage. Genau, wie das schnell auch funktionieren kann,
indem man einfach so eine Len und ein Get-Item definiert.
Ja, aber man ist nicht
delegiert, sondern
der ruft Len und Get-Item an.
Ja, aber das macht dann die interne Repräsentation von Längen
wird ja aufgerufen. Also das heißt, die Magie,
die wirklich dann in C-Python-
passiert, die ja damit schnell ist und so.
Okay, also er implementiert.
Gut, in dem Beispiel wird nicht implementiert,
wie du tatsächlich
Objekte speicherst, sondern benutzt eine Liste.
Genau, es wird halt sozusagen, das wird weitergereicht,
die Position wird weitergereicht an die Liste.
Genau. Und die kann halt auch
sein. Also die Implementierung
dieser beiden Attribute ist
tatsächlich,
ist einfach durchdelegiert. Aber
dass du dann daraus
eine Slicing-Syntax kriegst mit Render.
Ja, das ist ja, das macht ja der Interpreter
für dich. Ja.
Also der macht sich diese Ranges und ruft
dann die einzelnen Get-Items auf.
Ja. Also hat mich auch gewundert.
Hätte jetzt auch nicht gedacht, dass
man dann schon iterieren kann.
Genau, das war
mir gar nicht klar, dass das reicht, Get-Items
zu implementieren. Also ich muss meine naive
Karteninterpretation von meinem Kartenspiel, von meinem
Pokerspiel auch nochmal anpassen, wenn ich das so sehe, weil
tatsächlich ich da auch immer dann
ein Objekt gemacht habe, an dem Karten dran waren, was natürlich
dann eine Liste war, was aber nicht
hieß, dass man einfach das Ding mischt,
sondern man musste halt diese Mischmethode aufrufen. Ich glaube, das ist einfach
totaler Quatsch.
Ja, da gibt es aber auch verschiedene Ansätze.
Da kannst du auch auf verschiedene Arten und Weisen
drangehen. Du kannst drangehen und sagen, ich
mache jetzt eine neue
Klasse, die eine Liste
einpackt und dann halt so ein paar magische Methoden,
ich sage jetzt ja magische Methoden,
exportiert. Oder du kannst sagen,
ich behandle jetzt eine Liste wie
ein XYZ.
Und dann implementierst
du erstmal selber gar nichts, sondern
benutzt halt die Werkzeuge,
die es gibt, auf eine bestimmte Art und Weise.
Das sind ja schon zwei unterschiedliche, aber gleich
herangehensweise. Aber dieser letzte Ansatz,
das irgendwie wirkt, also smart,
weil man halt tatsächlich nicht das Rad
neu machen muss.
Und ich glaube, das ist eigentlich sehr PySonic.
Aber trotzdem sehr PySonic, sehr
Implizites. Und in der Kombination,
indem man das halt irgendwie schön
modularisiert, kann man tolle Sachen machen.
Also man muss so ein bisschen
Boilerplate schreiben vielleicht, aber wie man es dann hinterher
wirklich benutzt, wenn man diese Objekte in der Hand hat,
wirkt einfach wie PurePython.
Also, wenn man halt dann direkt auf dem Deck,
was man in der Hand hat, Indizes
machen kann, Ranges machen kann und so.
Ja gut, hier geht es ja vor allen Dingen
darum, diese Methoden zu erklären. Insofern
überhaupt, ob man das jetzt so implementieren würde, weiß ich nicht.
Also, keine Ahnung. Kommt drauf an, was man damit machen möchte.
Aber, ja.
Ja, ja, also ich finde es auch, ich finde es auch, also
es sieht gut aus. Kann jetzt keiner sehen,
weil es ein Podcast leider.
Aber, ja, ja.
Kannst du das teilen? Ist das public?
Äh, nee.
Oh.
Na gut. Also, ich glaube, es gibt irgendwo
bestimmt auf irgendwelchen Kanälen
oder sowas. Ja.
Das nächste Beispiel,
was er bringt, fand ich auch interessant, aber das ist natürlich
so ein bisschen dieses Vektorbeispiel.
Das ist natürlich mehr so ein bisschen
ja.
Du musst das einfach unterleuchtern, bitte.
Für alle unsere HörerInnen, was denn das Vektorbeispiel
ist. Ja, er
macht sich eine Klasse, eine
zweidimensionale Vektorklasse.
Also mit Richtung XY.
Genau, also genau.
Ein Koordinatenmodell, ein zweidimensionales
Koordinatenmodell. Er sagt auch gleich im
Vorhinein, könntest du auch die
Bild-In-Klasse komplex verwenden.
Die kann alles, was
wir gleich hier machen und noch viel mehr.
Aber zum Zeigen ist es ja ganz
schön. Und da implementiert
er drei Special Methods,
nämlich add, abs und mul.
Und
kriegt daraus dann
die Möglichkeit, zwei Vektoren zu addieren.
Abs
wird hier als die
Metrik implementiert. Das heißt, es ist die Länge
eines Vektors und mul ist
eine Skalarmultiplikation. Das heißt, kannst du einen
Vektor mit einem Integer oder mit einem
Float multiplizieren, kannst du die Länge
verändern.
Auch das mit wenigen Methoden
schon relativ viel erreicht
und auch relativ viel Syntax erreicht.
Das fehlt aber noch Vektor mit Vektor multiplizieren.
Ja, das ist nicht so
einfach. Das ist nicht so einfach, dummerweise, weil
mathematisch nicht so einfach.
Genau, da steht
glaube ich im Buch irgendwas drin. Ja, also wie man sagt,
das dann macht mit Magic Method, das ist dann
Kapitel 16 oder so viel weiter hinten,
weil das ist nicht so einfach.
Und er sagt auch, er verschiebt
auch, das tatsächlich in diesen ersten Kapiteln
verschiebt er relativ viel auch später.
Ja, hier, das kommt in Kapitel 17 nochmal oder
in Kapitel 38 oder Kapitel
12. Tatsächlich
auch Skalar mit
Vektor multiplizieren, also
eine Zahl mal Vektor
verschiebt er auch auf später, weil da brauchst du
nochmal einen anderen, eine andere Special
Method, weil eben mul nur
Vektor mit Skalar kann.
Und das ist dann so ein kleines
bisschen unbefriedigend. Was ich aber
eigentlich, worauf ich eigentlich raus wollte, ist,
er hat halt dann die Möglichkeit,
seine Klasse mit Plus, hat er zwei
Vektoren, zwei Instanzen von seiner Klasse
kann er mit Plus addieren. Und
das fand ich nicht so beeindruckend,
weil
das gab es in C++ auch schon.
Das musste ich auch schon mal lernen.
Und da heißen die Methoden
halt anders, da heißen sie Operator Plus und Operator
der Minus und Operator noch irgendwas
und dann kriegst du es aber auch.
Da kannst du auch Vektoren addieren und so weiter.
Deshalb, da war ich
jetzt nicht so beeindruckt davon.
Ich habe das mit dem Multiplizieren nicht verstanden,
was du meinst mit Skalar mal Vektor und Vektor mal Skalar.
Wo ist der Unterschied? Ist das nicht komputativ?
Das ist die Reihenfolge.
Eigentlich mathematisch gesehen
ist diese Operation komputativ,
aber in Python an dieser Stelle ist sie noch nicht
komputativ, weil wenn du
die Mull-Methode
implementierst
auf deiner Klasse,
dann musst
wenn du x mal y machst,
dann wird x.mull
aufgerufen. Weil ansonsten wird dann tatsächlich
ja, genau, sonst von dem
Skalar die Mull-Methode aufgerufen, da gibt es
den Vektor nicht. Genau, und die kann natürlich nicht mit Vektoren
umgehen. Und damit es in die andere Richtung geht, brauchst
du eine zweite Special Method, da heißt
r.mull, also Reverse Multiplication.
Und die hat aber auch später verschoben,
weil die später nochmal kommt.
Ach, man kann auch r.mull? Interessant.
Das wusste ich auch nicht. Genau, damit
eben diese Kommutativität.
Aber es wird zuerst mull aufgerufen.
Das heißt, da geht es dann
auch noch um Präzedenz und deshalb verschiebt
du das, glaube ich, auch später.
Wie kriegt man denn die Präzedenz hin?
Also ich möchte das gerne spoilern.
Die kriegst du hin,
also ist in dem Fall jetzt hier
tatsächlich unproblematisch, aber du musst dann natürlich
Type-Checks machen, dass du sagst, okay, was ist denn,
wenn ich ein r.mull mache mit
dieser oder jener Sorte von
Objekt? Weil da kann ja dann prinzipiell alles rein.
Ja, ich denke so.
Match-Case.
Ja, so
mit einem Match-Case oder mit einem
Alles, was du nicht implementiert hast,
wird einfach im Normalkreis abgehandelt und ansonsten
schreibst du für alle Cases, die
einmal auftauchen, was rein.
Finde ich gut.
Ja, im Endeffekt macht der Interpreter
das ja auch so. Also wenn eine von diesen
Methoden halt einen Fehler wirft oder
kein Ergebnis zurückgibt, dann wird
halt so lange weitere Methoden durchprobiert,
bis es eins gibt und wenn es keinen
gibt, dann sagt der Herr halt, ja, das ist nicht definiert für diese
Typen.
Das haben wir ja auch alle schon mal gesehen, oder?
Dass man versätlich einen String zu einer Zahl addiert hat
und dann gesagt bekommen hat, das kannst du nicht.
Es sei denn, man war in JavaScript.
Ja, ja, das ist halt so
ein fundamentaler Unterschied
zwischen JavaScript und Python.
Ja, also ich, genau, ich finde das ja auch sehr,
ich weiß nicht, haben wir überhaupt schon definiert,
mir fällt das gerade so heiß ein, jetzt reden wir schon die ganze Zeit drüber,
aber ich weiß nicht, haben wir überhaupt gesagt, was,
wie diese
Danda-Methods denn aussehen?
Also die sind immer, haben immer irgendwie
zwei Underscores, damit fangen sie mal an
und hören immer mit zwei Underscores auf
und Danda... Genau, Danda, für alle, die es nicht kennen,
ist Unterstrich, Unterstrich.
Danda ist halt quasi die Abkürzung für
Double Underscore Before and
Double Underscore After. Warum machen
Underscores damit? Man denkt, die gibt es gar nicht,
damit man die nicht sieht, damit die nicht auffallen.
Nö, Konvention.
Keine Ahnung. Wie du sie unterscheiden kannst von allen anderen.
Das ist eine Konvention
im Python-Interpreter, wenn du eine Methode hast,
die zwei Unterstriche vorne und
zwei Unterstriche hinten hat, dann
verspricht der Interpreter gar nichts
darüber. Das kann sich jederzeit ändern und es kann jederzeit
passieren, dass die nicht mehr funktioniert.
Es ist einfach nur eine visuelle Abtrennung,
dass du siehst, dass das was Spezielles ist.
Aber wenn ich das richtig verstehe, ruft man solche Methoden
niemals selber einfach so an?
Niemals, stimmt nicht so ganz, also ab und zu
schon, also eine ganz populäre ist, achso,
das wolltest du auch gerade sagen, weil
es halt dann erinnert.
Ja, also
wann ruft man denn Inet explizit auf? Von außen?
Ständig. Nur mit super?
Ständig, ne, ständig.
Wenn du halt Klasse, Klammer auf, Klammer zu,
dann hast du schon aufgerufen.
Nein, aber das ist ja die implizite.
Ich meine, dass du explizit
jetzt dran schreibst Inet.
Ja, okay, das passiert tatsächlich nicht so häufig.
Ja, bei super Aufrufen schon.
Ja gut, aber super machst du Inet.
Absolut im anderen Inet.
Und das offensichtlich, aber
außer dem Fall kenne ich jetzt
eigentlich keinen. Also es sei denn, man will irgendwas
debuggen oder sowas, dann war alles anders, aber
ja. Es ist halt auch nicht notwendig.
Das ist ja der Trick da dran.
Du brauchst die nicht direkt aufrufen, weil
es gibt da Syntax. Wenn ich jetzt ein App definiere, dann mache ich einfach
ein String, dann kriege ich das Ergebnis. Und wenn ich ein Apps definiere,
dann möchte ich halt irgendwie
mit Dingen rechnen und gucken, was passiert.
Oder beim Bool vergleiche ich mit irgendwas
oder so, oder ich mache ein If vor. Aber ich würde
niemals selber das vormachen. Und das ist ja
vielleicht das Interessante an den Dunder-Messages,
dass sie halt quasi die Reimplementierung
sind, um mit normaler Python
Syntax und den Objekten zu interagieren.
Also zum Beispiel Equals oder so, oder
Lesser-Send oder ein komparatives
Verhalten zwischen einzelnen Objekten von
Klassen oder von Instanzen.
Ja, du kannst halt sozusagen
mit dem Interpreter so interagieren, wie
die anderen Teile in Python halt
auch. Und das ist halt eine Besonderheit von Python,
das geht in vielen anderen Sprachen nicht.
Das macht es halt toll. Das ist halt
genau das Schöne an diesen
Magic-Messages ist, dass wenn man das ordentlich
implementiert, man hinterher in seinem Code
Sachen machen kann, die sehr
natürlich aussehen. Und die
auch in der logischen Sprache dann
natürlich Sinn machen, wenn man Dinge miteinander vergleichen möchte,
die man dann vielleicht auch vergleichen kann,
weil man denen ordentliche Namen gegeben hat und das aber einfach
mit den instanzierten Objekten geht. Und man
halt nicht irgendwie komische Dunder-Methoden
oder irgendwelche kryptischen
Namen an Objekten
aufrufen muss, wie das in anderen Sprachen der Fall ist. Und das
ist toll, weil diese Syntax sogar Magie
macht. Und deswegen finde ich den Namen
Magic-Message auch sehr schön.
Ja, du kriegst also Zugriff auf
die Innereien.
Dass Python integriert das
und du kannst dich da genauso rein
integrieren wie alle, als ob du
dazugehörst. Und das ist schon was sehr Schönes.
Aber du hast eben noch was anderes gesagt, Dominik,
was auch hier vorkommt, was ich auch in meinen Notizen
habe. Du hast gesagt, du möchtest hier
die String-Methode implementieren und dann kriegst du
eine schöne String-Repräsentation raus.
Ich habe die Rep-Methode gesagt.
Oh, dann muss ich noch mal
zurückscrollen und mir das anhören.
Aber das ist tatsächlich was, ich tendiere
auch dazu, immer die String-Methode zu implementieren,
weil man
es halt so gewöhnt ist. Bei Java machst du
Two-String, bei irgendwelchen anderen
machst du irgendeine Two-String-
Transformation oder was auch immer.
Und in Python gibt es da ja zwei
davon. Es gibt Repre und Stre.
Genau.
Und der Unterschied ist
schwer zu
erklären,
weil es nicht so
was Formales ist.
Die Repräsentation ist das, was in der
Kommandozeile auftaucht oder einem String, wenn du ihn
da reingeschrieben hast und Stre ist das,
was rauskommt, wenn du die String
Conversion versuchst.
Ja, aber warum
macht man dann da überhaupt einen Unterschied?
Könntest du da genau mit einer machen dann?
Das Identifiziert das Objekt?
Okay, erklär du, Johannes.
Ja.
Ne, also das
geht schon so ein bisschen runter auf die Krux des
Problems, weil diese zwei Methoden doch
relativ ähnlich sind.
Aber interessanterweise, wenn du Stre
nicht implementiert hast, fällt der zurück auf Repre.
Also auf die Repräsentation.
Und die Repräsentation
ist in dem Sinne ein bisschen formaler, weil
das heißt, du sollst
eine Repräsentation wählen, die du idealerweise
direkt in den Interpreter rein
kopieren kannst.
Und das schränkt dich natürlich relativ ein.
Das heißt, da hast du üblicherweise dann sowas wie
eben einen Konstruktor da drinstehen.
Oder eine String-Repräsentation
des Konstruktors. Die Stre-Methode
soll einfach nur eine menschenlesbare
Beschreibung dieses Objektes sein.
Und die kann dann natürlich auch was anderes sein.
Also zum Beispiel für
diese Vektorklasse, da hat er
als Repräsentation halt den Namen
der Klasse, Vektor 2, Klammer auf,
dann die beiden Koordinaten
und dann Klammer zu.
Und das ist gut, weil das
kannst du direkt reinkopieren, das identifiziert
genau diese Sache.
Als Stre-Methode, hat er jetzt hier
kein Beispiel im Buch drin,
würde ich aber tatsächlich was anderes
wählen. Ich würde entweder
je nach Kontext
vielleicht eckige Klammern wählen.
Oder in einem mathematischen Kontext
vielleicht sogar runde Klammern.
Genau, spitze Klammern, Entschuldigung.
Oder vielleicht sogar runde, je nachdem,
welchen Kontext es hat. Und da hat man natürlich einfach
mehr Freiheit, weil das einfach eine
menschenlesbare
Darstellung dieses Objektes sein soll.
Und ich
tendiere eher dazu, die Stre-Methode zu
implementieren und die Argumente,
die hier der
Luciano uns gibt,
ähm,
die lassen mich jetzt doch auch tendieren
dazu eher Rapper zu sein.
Also das ist sozusagen die Regel, die man da mit
mitnehmen kann, ist halt, wenn man die,
wenn man sozusagen
sich entscheiden muss, dann lieber eher nur die
Rapper-Methode implementieren, nicht unbedingt Stre.
Ja.
Und das war mir auch nicht so
in der Feinheit klar,
was jetzt da der genaue Unterschied oder der Sinn dahinter
ist. Und das weiß ich jetzt voll gut.
Weiß ich schon wieder mehr.
Ja. Ja, das war gut, oder? Ja.
Ja, ja, ja.
Das, äh, ich, ich war etwas
überrascht, als ich das Buch angefangen hab, weil das erste
Kapitel schon ordentlich
rangeht. Ein länger Buch, hat Jocken gesagt.
Ja.
Nein, das ist auf jeden Fall ein
fortgeschrittenes Buch und der, also der macht
auch keine, keine Pausen, ja.
Der geht direkt weiter hier.
Zwei, zwei Klassen mit Operatoren,
also das ist diese Deck-Klasse und die
Vector-Klasse und dann macht er noch
Bool-Implementierung und dann geht
es gleich mit der Collection-API weiter.
Auch das,
sehr interessant, äh, sehr
interessanter Abschnitt über die Collection-API,
wo natürlich jetzt mehr an Details drin ist, die,
die ich weder präsent
hatte, noch jetzt so präsent habe.
Ja, also jetzt musst du aber trotzdem
mal kurz, äh, einmal
aufräumen, bitte. Ja, dafür
ist das Buch halt, also das Buch ist schon dicht, okay,
ich geb's zu, aber dafür ist es halt auch nicht so lang.
Ähm. Ja, das steht
nur, die nächste Lüge
von Jocken. 975
Seiten. Ja, ich würde sagen. Aber es ist,
es ist ein Taschenbuch-Format, also kann man,
wenn man es mal locker in, auch in die Tasche stecken,
ist es auch relativ klein.
961. Also so vielleicht
18 mal 20 Zentimeter.
Ja, also das ist auf jeden Fall doch die Größe,
die man sich locker unter das Kopfkissen legen kann.
Damit sich man automatisch lernt, ja.
Du kannst ja dein Kopfkissen ersetzen, kannst du
das mit dem Buch.
Ja.
Ja, aber tatsächlich, also diese,
diese, ähm,
da ist sogar ein UML-Diagramm, das, also
muss ich sagen, da war ich so fast ein bisschen abgeschreckt.
Jetzt kauf ich's auch.
UML-Diagramm, oh Gott, oh Gott.
Oh Gott, aber, äh, ja, in der Stelle
macht's tatsächlich Sinn.
Ja, ähm, genau.
Das ist ja hier der Dominik und ich, wir blättern jetzt gerade
für die, für die Zuhörer.
Ja, ich, genau, da gibt's, gibt's halt
ein, ein, äh, ein UML-Diagramm
von der Collection-API.
Was ist jetzt die Collection-API? Ich hab's immer noch
nicht genau verstanden. Bitte, äh, wiederhol das doch noch mal.
Ja, also, die ist, äh,
Was ist, was ist überhaupt eine Collection?
Ist da, geht's, um, um was geht's da?
Etatools oder?
Nee, äh, da geht's darum,
wie grundsätzlich
quasi Objekte
in Python, äh,
irgendwie so funktionieren, die eine Collection
von irgendwas sind. Und das sind,
das sind halt die allermeisten, ja. Das sieht jetzt hier nicht so aus,
sieht nach irgendwas Speziellem aus, aber das sind halt
die allerallermeisten sind da, sowas.
Und, ähm, da gibt's
also Collection selber,
äh, damit's eine ist.
Man soll nicht verklicken, äh, Jochen, aber, ähm.
Also, damit's, damit's eine ist,
äh, äh, quasi müssen drei
Sachen irgendwie, äh,
ja, implementiert sein. Also, es gibt halt drei
Methoden, die, äh,
sozusagen dann ein Ding zu einer Collection
machen und das ist halt.
Iter? Iter, ja. Du kannst halt irgendwie
drüber iterieren. Äh, das heißt.
Also, einen Iterator bauen, einen Generator,
der irgendwas yieldet. Nee.
Nein. Äh, du kannst halt, es muss halt
irgendwie. Aber jetzt, fast. Ja.
Mal ganz generell, so eine Collection
ist einfach eine Sammlung
von anderen Sachen. Ja.
Eine Sammlung von anderen Dingen.
Und um das zu ermöglichen, gibt's jetzt hier
diese verschiedenen Interfaces, die der Jochen
jetzt gerade. Okay, erst mal, es muss ein Iterable
sein, ja, und dann? Ja. Es muss irgendwie.
Muss nicht, aber kann.
Doch, muss eigentlich. Also, eine Collection,
okay, eine Collection, äh, muss das schon
sein. Ja. Aber es kann ja, es kann etwas
geben, was Iterable ist, aber keine Collection ist.
Ja, klar, genau. Das gibt's natürlich. Ja, ja, okay. Aber eine Collection
muss Iterable sein und das ist irgendwas, was
gilt. Sie muss halt Iterable sein, also. Oder nicht? Ja.
Sie muss halt, äh, irgendwie eine Größe haben,
sie muss halt Size sein und sie muss
halt, äh, irgendwie ein Container
sein, den man halt fragen kann,
ja, ist das denn in dir
drin oder nicht? Und das
sind die drei Dinge, die man halt, äh, quasi
implementiert haben muss, damit man irgendwie eine Collection
ist. Also, ist, ist this a part of your collection?
Ähm, wie viel bist du
denn? Und, äh, gib mal
mehr von dir. Von allem, was
in dir drin ist. Ja, gibt's immer mehr. Das heißt, wenn ich über
alles iteriere, dann hab ich alles drin, was drin war.
Alle, alles Toys.
For everything in collection
iter. Ist das, ist das so, Jochen?
Müssen, müssen Iterate über alle
Elemente drüber? Nee, ich denk nicht, ich denk nicht.
Also, du kannst ja dann in der, wenn du das
implementierst, da drin ja machen, was du willst.
Das, äh, das kann jetzt auch
von irgendwas anderem abhängig sein, was das
so gibt. Du musst nur das Iter-Protokoll erfüllen. Ja, genau.
Du musst nur das Protokoll erfüllen. Ja. Ein, ein
nächstes rausgeben. Ja, ja. Also immer dasselbe.
Also, diese pathologischen Edge-Cases.
Gib mir mal alle in deinem Ding. Ich will das erste. Nee, du kriegst das erste.
Du kriegst doch das erste. Nein, das und das erste.
Immer noch das erste. Nee, nee, das ist, nee, nee, du rufst
ja, das Iter, Iter-Protokoll ist ja, du rufst immer
Next auf, auf dem Iter-Protokoll. Ach, das ist doch kein
Erwartung. Das heißt, du kriegst immer ein nächstes Element.
Aber das bedeutet nicht, dass du alle kriegst und
das bedeutet auch nicht, dass du alle kriegen kannst.
Es gibt da diese pathologischen Edge-Cases,
die man immer in Einführungsveranstaltungen
macht, dass man sagt, hier, wir machen jetzt jetzt mal was
Iter-Protokoll und das berechnet einfach
die nächste Primzahl. Es gibt ja alle Primzahlen.
Aber das ist natürlich keine Sammlung,
die je aufhört. Und was, was ist denn da unter
Primzahlen, Iterin? Unterschied,
äh, Joachim, mit dem
Generator und dem, dem Next und dem Yield und dem
Naja, also, weil, also Iter
ist halt die grundsätzliche Geschichte. Das
ist halt das, was du brauchst, wenn du vor
irgendwas in irgendwas sagst.
Ja, ein Generator ist eine spezifische,
ist halt nicht so allgemein. So ein Generator heißt
halt dann, äh, äh, sozusagen
da, äh,
ja, kriegst du halt eins nach dem anderen drin.
Aber, halt im Moment, also wenn ich jetzt irgendwas
iteriere, ist was anderes als ein eins nach dem anderen?
Äh,
also, sagen wir mal so,
Generator ist nochmal eine ganz, ist nochmal eine
speziellere Geschichte. Das hat halt irgendwie,
das ist jetzt nicht das Gleiche wie, wie
irgendwie was, was du iterieren kannst.
Das ist was anderes. Ein Generator implementiert
ja, ein Generator implementiert
das Iterable-Protokoll. Also, Generator ist, ja, genau,
klar, also ist schon Iterable ein Generator,
aber es ist ja eine sehr spezielle Art von was
Iterable. Aha, also, aha,
okay, weil. Aber eine Liste
ist auch irgendwie was Iterable ist,
aber das ist kein Generator, gar nicht.
Nein? Nein. Als Comprehension schon.
Also, wenn du eine List Comprehension schreibst,
kriegst du eine Liste zurück.
Du kannst den Generator Expression hinschreiben, dann kriegst du
einen Generator, aber das ist wieder was anderes. Also,
mhm, ja.
Aber interessant
finde ich halt, dass das halt reicht.
Ja, also, diese drei Dinge, also, wenn du
halt die, wenn du die Dunner-Methods
Iter, Len und Contains implementierst,
dann hast du halt ein Collection,
quasi, und
dann gibt's halt noch die eine zusätzliche Geschichte,
die halt sozusagen
dann daraus etwas,
nochmal was Besonderes macht, das ist halt
Reversible.
Wenn das irgendeine Reihenfolge
hat, dann ist es halt eine Sequence
Ja, aber das ist halt das, was
das unterscheidet. Also, eine Sequence
kann halt irgendwie beliebig sortiert werden,
so, das macht es halt besonders, und
dann, ja. Und das klassische Beispiel ist eine Liste.
Liste ist eine Sequence. Wenn man Sequence
sagt, kann man immer an Liste denken. Ja.
Und, äh, genau,
ansonsten ist halt
ein Dict ist halt auch ein Collection,
ist halt ein Mapping,
sozusagen. Und ein Set
ist keine Liste, aber ein Set ist schon
eine Collection. Genau, das ist schon eine Collection.
Das ist der Basistyp. Aber keine Sequence. Genau. Also, das sind ja
die Basistypen, die sie da ableiten. Sequence, Mapping
und Set. Und, äh,
die drei verhalten sich unterschiedlich
und daraus, das sind aber die Dinge, die man dann einsetzt.
Also, diese Bausteine, also
ein pures Iterable, ich meine,
geht prinzipiell schon, oder ein
pures Sized,
ja, ist nicht nett, dass ich das schon mal gesehen
habe. Aber natürlich Sequence und Mapping
und Set, das sind die Sachen, die man dann tatsächlich benutzt.
Weil da hast du dann die Bausteine zusammengesetzt zu dem,
was man tatsächlich einfach braucht.
Das, was dann sinnvoll ist.
Ja. Und da kann man
dann auch Beispiele sagen, ja. Also, ein Beispiel
von einem Iterable könnte ich jetzt nicht unbedingt sagen.
Also, von einem puren.
Ein Huhn. Ein Huhn ist ein Iterable.
Legt ein Ei, legt noch ein Ei,
legt noch ein Ei, legt noch ein Ei.
Ja, das wisst ihr jetzt nicht,
wenn man es in Python implementiert,
aber ja.
Es gibt auch Hühner
in Pythons. Dann ist halt die Frage,
was war zuerst da? Das Ei oder das Huhn?
Ja, weiß auch nicht.
Wenn du eine große Schlange hast, kannst du ja mal einen Huhn
reintun und dann schauen, ob es iteriert.
Ich habe letztens irgendwo so ein Schaubild
gesehen, wo ein Biologe meinte, so war es
eine Quatschfrage. Also, wir malen
hier einfach mal so diesen evolutionären Schlangenbogen
auf und da haben wir überall Eier, aber nur
da ganz unten ein Huhn.
Natürlich war das Ei zuerst da.
Völlig
triviale Frage.
Ja. Okay.
Genau. Und Mapping, ich meine,
das kennt man auch, das ist ein Dictionary und Set kennt man auch,
das ist ein Set. Und das sind dann die Sachen, die man tatsächlich
benutzt. Aber diese Protokolle,
also das, was die tatsächlich an Funktionalität
anbieten, das ist hier
zusammengesetzt aus diesen ABCs, aus den
Abstract Base Classes.
Benutzt die tatsächlich immer?
Der Trick ist, dass
wenn du diese ABCs implementierst,
dann, genau wie vorhin bei den
Special Methods oder bei den Magic Methods,
dann kannst du dich in den Python Interpreter so rein
integrieren, wie wenn du ein Dict wärst
oder eine Liste oder was auch immer.
Also dann habe ich ein Interface
implementiert. Kann man das so
sagen? Ja, es heißt hier nicht Interface, sondern Protokoll.
Aha. Das heißt,
beim Typing Protokoll kann ich das dann benutzen.
Das ist nochmal eine andere
Geschichte, aber ja, das funktioniert dann, das ist
eine andere Art, das zu machen. Aber das macht
quasi genau, deswegen, also Abstract Base Classes,
ja, braucht man das? Nein. Also du kannst,
das Problem bei den Abstract Base Classes,
das ist halt, es funktioniert halt anders.
Es ist halt sozusagen, das hatten wir in der
Typing Episode auch, es ist halt
sozusagen nominatives,
nominative Typisierung
sozusagen in dem Sinne, dass du jetzt bei
jedem Ding, das du erzeugst,
dadurch, dass du von so einer Abstract Base Class erbst,
sagst du halt genau, was es ist.
Und es ist das, weil
du es davon erbst. Genau, bei Protokoll nicht,
weil es kann nicht das sein, weil das ist im Protokoll
eigentlich viel flexibler für sowas
und auch viel besser geeignet.
Ja,
ja, aber es hat dann natürlich auch wieder
Nachteile. Naja, wenn du sagst, es muss
eine Collection sein, die da reingeht, dann ist doch scheißegal, was
für eine Collection das ist.
Wenn das das Protokoll der Collection erfüllt
und die dann, das Mapping
oder das Set oder sowas, und da ist irgendein Set, das da
rein muss, aber du sagst halt, es muss halt diese Sachen,
die da drin haben, die im Protokoll
definiert sind, also in den Methoden,
die man für ein Set halt braucht.
Genau, aber was sagst du ja damit? Ja, aber dann
ist das doch okay, aber da muss ich doch keine Abstract Base
Klasse verwenden, das ist irgendwie komisch.
Doch, klar. Das ist ja genau
die Formalisierung davon.
Du erbst von dieser Abstract Base Class,
dann hast du erstmal nichts umgesetzt, dann implementierst du die ganzen
Sachen. Nein, Protokoll. Dann wirst
du zu einer Collection. Deine Klasse ist
eine Collection. Dann kannst du es auch überprüfen.
Wenn du nur im Typing sagst,
das entspricht dem, dann hast du es nicht überprüft.
Wenn du nur im Protokoll Dings machst, dann würdest du sagen,
ist Collection, also ist Instance
auf Collection, sagt dir halt, ne,
eher nicht.
Was du dann machen kannst,
ist halt, dann dein
statischer Type Checker kann immer noch Fehler
finden. Ja, genau.
Mein Linter sagt mir halt, ja, nee, aber der
will jetzt ein Collection haben und nichts anderes.
Ja, aber wenn da jemand anders
ein ist Instance auf deinem, was auch
immer das Ding ist, irgendwie aufruft,
dann kriegt der nicht und sagt, ist das eine Collection?
Dann kommt er zurück, nö, ist nicht.
Ja, okay, weil das kein hartes
Geerbe ist. Weil es ist nicht wirklich eine Collection
in dem Sinne. Ja, aber es interpretiert nur das Protokoll
als wäre es eine Collection.
Genau, also das ist quasi die
Formalisierung davon. Du gibst
es technisch rein und sagst, das ist eine
Collection. Glaubst du der Sprache,
die das mit Instance überprüft,
oder glaubst du deinem Linter, der dir sagt,
das könnte passen oder nicht?
Naja, es hat halt alle so Vor- und Nachfälle.
Den Linter glaube ich überhaupt gar nicht. Ja, aber warum will ich denn
jemals testen, ob es ist Instance auf Collection ist?
Ich will nur wissen, ob dann das lintet, weil es die
Methoden implementiert.
Und ich will, ob es Instance
auf, keine Ahnung, meine Superliste
dann gibt.
Da gibt es ja schon Use Cases
dafür, dass du sagst, okay,
ich habe eine Funktion, die alles mögliche
verarbeiten kann,
muss ja schon eventuell auf unterschiedliche
Arten drücken. Nein, aber ich will wissen, ist Instance
Buch? Weil wenn ich nach der Bücher-Collection
gucke und ich will niemals wissen,
ob es eine Collection von irgendwelchen
abstrakten Dingen ist. Deswegen ist es Bullshit, das mit
abstrakten Base-Classungen. Meiner Meinung nach ist das super,
wenn es ein Protokoll gibt. Damit, dass du noch nie eine Bibliothek-Implementierung
die so eine Funktion hat.
Funktionalität anbietet, ist jetzt
schade, aber so ist es.
Ich meine zum Beispiel,
wo das halt häufig
auftritt, also wo ich das kenne mit
denen, dass man halt irgendwie, es gibt halt viele
Methoden, zum Beispiel nehmen wir jetzt bei Data Science
Geschichten, irgendwie sowas wie
irgendwie Data Pipelines oder irgendwelche
Modelle oder so
und da kommen halt
manchmal so wirklich komische Sachen rein
und ich
habe auch schon viel
Scikit-Learn-Code zum Beispiel gelesen und so
viele Methoden oder
viele Funktionen, die fangen an mit
also, sag mal,
bist du eigentlich ein sowas? Oder bist du
vielleicht sowas? Und dann machen sie halt unterschiedliche Dinge,
je nachdem, was das dann ist und
das ist halt teilweise, das ist wirklich
lang am Anfang und
ja, ich wüsste jetzt nicht,
wie man das anders machen könnte, außer so, also
hmm
also, ja
Eine Sorte Funktion,
die man auch häufig sieht in Bibliotheken
ist, wo du entweder
einzelne Elemente reingeben kannst oder gleich
eine ganze Sammlung. Und dann musst du halt auch
am Anfang dieser Funktion in der
Implementierung unterscheiden können, ob du jetzt gerade ein
einzelnes Element in der Hand hast oder ganz viele
einzelne Elemente. Und da
musst du schon irgendwie eine formalisierte
Unterscheidung machen, da hilft dir auch der
Linternix, weil der geht ja zur Laufzeit nicht.
Also
es macht schon seinen Sinn,
diese Sachen so zu deklarieren,
insbesondere, wenn du eben hier solche,
sag ich mal, grundlegenden Funktionen
implementierst.
Man kann das auch zu weit treiben,
wenn man das zu weit treibt, dann kriegt man Java.
Ja.
Und
man muss da eine Balance finden.
Ja.
Aber es ist,
um wieder darauf zurückzukommen,
es ist schon interessant, dass das eigentlich so relativ
simple Sachen sind. Also hier dieses
UML-Diagramm ist eine Viertelseite
und es stehen ja wirklich nicht viele
Sachen da drin. Ja.
Es sind nicht viele Methoden, die man umsetzen muss.
Ja, und das ist halt irgendwie
quasi,
also die meisten oder viele
Leute werden sich niemals aus diesem Universum
von dem, was da definiert ist, rausbewegen,
weil damit quasi fast
alles erschlagen ist, was man so normalerweise so tut.
Das ist schon faszinierend, dass das geht, ja.
Ja, außer Skalare.
Okay, die stehen da jetzt auch nicht so normal.
Ja.
Ja, und dann ist das erste
Kapitel ja schon fast vorbei. Dann haben wir noch hier die Übersicht
der Dunder-Methods. Da wird einmal nochmal
komplett alle aufgeführt auch.
Ja. Schön, so völlig ohne
Zusammenhang hier mit Metaprogramming
und Abstract-Base-Glasses und
Attribute-Descriptors und Attribute-Management.
Also da
ist es interessanter reinzuschauen,
was es alles gibt, aber ich wüsste jetzt nicht
bei allen, was die tun. Was ist der Unterschied
zwischen Get-Attribute und Get-Attribute?
Ja, es kommt in Kapitel.
Ja.
Also das eine ist
irgendwie nochmal ein Stückchen
allgemeiner, glaube ich, als das andere.
Ich glaube, Get-Attribute ist halt das,
das wirklich ganz allgemeine Ding.
Und Get-Attribute ist halt, guckt halt wirklich
ganz tief runter.
Das eine ist näher dran, oder?
Ja. Also Get-Attribute kannst du
auch Methoden überschreiten.
Genau, die Frage ist halt, wann, welches Dick das reinguckt,
wenn du guckst.
Aber so ganz genau weiß ich das jetzt auch
alles nicht. Oder In-It-Sub-Class.
Wüsstest du, was In-It-Sub-Class macht,
Johann, oder Prepare? Ich weiß es aus
einem,
wir haben ja auch schon die Wechsel-Saison wieder.
In-It-Sub-Class, das ist halt,
der Grund, warum Leute
Meta-Klassen verwenden, ist eigentlich der,
dass sie halt irgendwie die Klasse-Instanzierung
ab und zu mal so ein bisschen modifizieren wollen.
Und fast alle Use-Cases lassen sich,
also Meta-Klassen selber zum Benutzen ist
super viertelig. Man muss
extrem aufpassen, was man da tut.
Und
daher ist das halt so ein bisschen auch in Verruf
geraten. Und Leute raten einem davon immer ab,
das zu machen.
Aber genau, man
kann,
wenn man jetzt In-It-Sub-Class
verwendet,
dann kann man fast alle Anwendungsfälle, für den
Leute normalerweise so Meta-Klassen verwenden,
halt damit hinkriegen und
hat all diese Probleme nicht, die man halt sonst
so kriegt, wenn man Meta-Klassen verwendet.
Und das ist
eingeführt worden mit Python 3.6. Und ich weiß das
halt nicht deswegen, weil ich sowieso immer alles
weiß, sondern in dem speziellen Fall,
in dem speziellen Fall weiß ich es,
in diesem Fall weiß ich es,
weil den Pep dafür hat
irgendwie, wir hatten ja Martin hier
auch mal zu Gast, der irgendwie dann in diesen
XFile-Rond-Laser geschrieben hat.
Und den Pep zur Einführung von In-It-Sub-Class,
den hat er geschrieben und ist
damals in Python 3.6 reingekommen.
Ja. Und deswegen hast du natürlich ganz
besonders. Okay, dann habe ich jetzt das Falsche gefragt. Dann
sag mal, was Sub-Class-Check macht der Hund? Weißt du mal alles?
Ja, siehst du. Weiß ich nicht. Keine Ahnung.
Ja, okay, gut. Also das kommt dann in einem
späteren Kapitel und da sind auch
MRO-Entries. Also ich meine, dass man
da sein MRO bearbeiten kann, das ist ja
schon hart.
Kann man sich einfach sagen, ich bin jetzt
ein bisschen tiefer implementiert und ich bin
jetzt einfach type.
Ja, keine Ahnung. Ich weiß es nicht.
Wir werden
es im Laufe dieser Vortragsreihe
eine Type
vielleicht lernen.
Genau, aber was mich also auch
überrascht hat, ist, dass wie viele... Oder machen wir jetzt das ganze Buch
heute.
Genau, ja. Das wird jetzt ein bisschen dauern.
Einmal ansteigen.
Türen schließen.
Was ich auch
irgendwie nicht erwartet hätte,
also ist das halt so viel
Volkssicht um arithmetische
Geschichten und Operator
Overloading. Also mehr als
die Hälfte. Und das
hätte ich jetzt nicht gedacht.
Wenn man mich jetzt nachts geweckt hätte und gefragt hätte,
was machen die Menschen, welche Magic Methods gibt's
und was machen die so, dann wäre ich jetzt bei
sowas wie Repre oder
irgendwie, genau, Bool oder
weiß ich nicht, sowas gewesen.
Ja, es ist auch, es geht in
beide Richtungen und dann geht's mit Integer und dann
gibt's mit Reversed und dann gibt's mit Augmented und dann
gibt's mit Bitwise und mit Reversed und
Augmented. Also das gibt's alles
in drei verschiedenen Varianten.
Jeweils. Ja. Sonst sind's
ja nicht so viele, aber es...
Ja.
Ja, ja, ja. Ja gut, Mathematik
regiert die Welt. Ja.
Das, das, ja.
So ist es.
Ja.
Ja, dann, das ist doch interessant
hier. Und am Ende seines Kapitels
hat er immer noch einen Soapbox
...
Abschnitt. Eine Seifenkiste. Den finde ich auch
sehr schön. Ja, ja, genau, wo er sich
hinstellt und mal ein bisschen predigt. Und das, das
fand ich ja tatsächlich auch sehr schön.
The Art of the
Meta-Object Protocol.
Großartiger Buchtitel
und hab ich mir jetzt auch mal auf meine Liste
... Das musst du noch mal genau
erklären, bitte.
Ja, ich weiß es auch nicht. Ich hab's auch noch nicht gelesen, aber ich fand den Titel
gut genug, dass ich es mir direkt auf meine Leseliste
gesetzt hab.
Was ich viel
interessanter fand noch, war ganz am Ende was,
wo er sagt hier, der Autor,
der dieses AMOB-Buch geschrieben hat,
Art of the Meta-Object Protocol,
der hat Aspect-Oriented Programming
entwickelt oder getrieben.
Und
ich hab's dann mal auf Wikipedia
nachgelesen, was Aspect-Oriented Programming
ist, aber nicht so richtig
verstanden.
Also Aspekte sind auch irgendwas mit Magie, oder?
Da geht's entweder Wasser oder Feuer
oder ...
Irgendwas mit gegen die Muggel.
Ja, vielleicht. Ich weiß es.
Ich weiß es nicht. Da muss uns mal jemand erklären.
Da würde ich gerne mehr wissen, wie es geht.
Aber da sind auf jeden Fall
in dieser Soapbox sind schöne Pointer drin, wo man
dann dem
geneigten Leser als Übungsaufgabe
überlassen werden.
Vielleicht werden die Designer von Go irgendwann
das Meta-Objekt-Protokoll erweitern.
Aber das ist im Moment nicht das,
was man
auf dem Niveau, mit dem man in Python arbeiten kann.
Genau, das ist halt das, was er hier
dann sagt. In anderen Sprachen hast du diese
Möglichkeiten nicht. In Go gibt's halt nicht.
Magic-Sachen, weil die halt im
Interpreter drin sind, kommst du auch nicht dran, kannst nichts machen.
Und
Pech gehabt. Und das ist
in Python eben nicht so. Deshalb hier
Muggel-Methods.
Jeder kann da hingehen und die Finger drauflegen
und dann so tun, als ob er zu Python
gehört.
Du wolltest damit einen exklusiven
Kreis aufmachen, lieber Johannes.
Du musst nur die magischen Worte
wissen und in der richtigen Reihenfolge sagen und
dann deinen Zauberstab in der richtigen Bewegung schwingen.
Ja, du musst aber schon noch in jede Ecke vom Raum schon eine Kerze
reinstellen und so.
Das ist dann,
das ist Meta-Programming, was du da meinst.
Und Meta-Klasse.
Da muss man immer ein bisschen aufpassen, was man damit
sich heraufbeschwört, wenn man zu viel
Meta macht, dann das kann auch.
Zu viel Magie.
Wie sagt man?
Merry meet, merry greet.
And merry meet again.
Also,
wegen des Heraufbestands.
Das erste Kapitel war nicht so lang.
Nö, ich war überrascht.
Es fängt
ordentlich an und ist dann aber nach
also hier 19 Seiten schon vorbei.
Also, das fand ich
überraschend. Der legt ordentlich los
und macht dann aber gleich direkt eine Pause.
Ja, ja, und danach kommen dann jetzt
irgendwie Sequences und, und, und, und.
Ja, das ist ja deutlich länger.
Und ja.
Da hatten wir schon mal drüber gesprochen.
Aber, genau. Ja, Pattern Matching ist ja auch
sowas, das haben wir auch noch nie wirklich ausführlich
besprochen. Das sollten wir vielleicht auch mal
tun. Jetzt gibt es dann Kapitel 2.
Ja.
Das ist dann, das ist tatsächlich etwas über 60 Seiten
lang. Das ist dann gleich deutlich länger.
Tja. Aber ich meine, wenn man auf 980
Seiten kommen will, muss man auch mal
ab und zu mal eine füllen.
Kapitel machen. Ja.
Wie viele Kapitel
gibt es denn? Gar nicht nachgeguckt.
Ich habe einfach losgelesen, ohne zu lesen,
wie viele Kapitel es gibt.
Ja, du hast doch viele. 900 Seiten. Hast du ein bisschen Platz.
24 Kapitel gibt es.
Ah ja. Hätten es 25 sein sollen.
Oder wie ist da eine andere von den magischen Zahlen,
damit man auch in die richtige Stelle kommt?
Nee, 24 ist doch gut.
Das ist eine
Abandoned Number, oder?
Das ist doch eine, wo die Summe der Teile
größer ist als die Zahl selbst.
Okay.
Ist doch immer gut.
Aha.
Ja, jetzt kommen die Mathe-Nerds
raus.
Okay, kannte ich auch noch nicht.
Ja.
Da habe ich eine Buchempfehlung
dazu, wenn dich das interessiert.
These Wonderful Numbers.
Da ist quasi
zu jeder Zahl sind die Eigenschaften beschrieben.
Hm.
Das ist ein sehr
nerdiges Buch für nerdige Mathematiker.
Einfach keine Angst haben,
die Dunkelheit länger ins Auge zu schauen.
Je älter man wird, desto mehr
versteht man davon auch.
Als Mathematiker hat man da keine Angst davor.
Hat auch wieder was mit Magie zu tun.
Worte der Weisheit.
Genau. Spezielle Art von Magie.
Genau.
Da wir die ganze Zeit von Magie reden,
würde ich gerne meinen Pick tatsächlich nehmen.
Ja.
Ich nehme doch tatsächlich
noch einen Euro-Python-Talk, weil
der liebe Rodrigo
einen sehr schönen Talk
gemacht hat über so
Turtle. Kennt ihr vielleicht?
Auch ganz magische Sachen macht das. Das kann
Dinge auf die
Leinwand malen, die sich drehen,
spiralen. Und dann kann man das erweitern,
auch zu Fraktalen. Und damit kann man animierte
Fraktale für
Live-Performances zum Beispiel
schreiben.
Und zwar relativ einfach, indem man so einfache
mathematische Prinzipien verwendet. Und da war ein toller Talk zu.
Und er hat auch einen schönen Blog-Post dazu geschrieben.
Deswegen würde ich den gerne mal in die Show umzlinken.
Okay, okay.
Okay, gut. Cool. Spannend.
Mhm.
Ich habe heute zwei Picks dabei.
Der erste Pick
ist ein Buch
ähnlichen Ausmaßes
wie Fluent Python.
Ich halte mal hier die Kamera für die anderen beiden.
Oh, okay. Noch ein Schläger.
Als es kam, ist es, es hat ein tatsächlich
ähnliches Format. Es heißt
Django 5 by Example
von Antonio Mele.
Und
ich glaube, dass das
ähnlich ist wie Fluent Python,
nur halt für Django.
Ach, sehr cool. Ganz, ganz frisch mit
Django 5.
Weil, also hier, ich habe es leider noch nicht durchgelesen.
Es ist, wie gesagt,
auch das, auch dieses Buch hat
ja, 750 Seiten,
ein bisschen weniger, aber trotzdem ein ähnliches
Format.
Was ist das mit diesen Autoren von
Programmierhandmüchern? Warum müssen die immer
so viel schreiben?
Es dauert irgendwas nicht richtig mit drin.
Es gibt viel zu sagen.
Ah ja, gut.
Und
ich glaube, der Trick da drin ist,
halt, dass es bei Example ist und
eben sehr viele
einfach handfeste Projekte
enthält, wo er sagt, hier, wir machen
jetzt mal, hier, wir machen
mal einen Blog und jetzt machen wir mal noch mehr Blog und
jetzt machen wir mal noch mehr Blog und jetzt machen wir mal noch Social
Website und Social Authentication
und Content Sharing und Online
Shop und Tracking User Actions und
Managing Payments and
Orders and Extending Your Shop und
Internationalization und
Caching und E-Learning und
Content Management und API und
Okay.
Das ist, glaube ich, geht so ein bisschen
in die Richtung, wo
auf Lohnpeisen hingeht, dass es
halt über die Basics hinausgeht
und ich glaube, dass das
eine Lücke in meinem Bücherschrank
füllt, von der ich bisher nicht wusste, dass
ich sie hatte und das freut mich sehr.
Ah ja.
Also hast du jetzt endlich Zeit, deinen
Dango-Webshop zu implementieren, von dem du schon die ganze Zeit räumst?
Mein Blog, ich werde jetzt endlich mal
meinen Blog
modernisieren.
Das war gestern, jetzt ist es wieder.
Ja, nee, das ist doch langweilig.
Ich muss dynamisch sein und mit User Tracking und mit
Payments and Orders.
Ja, das wird ja auch mal Zeit.
Ja, ja, klar.
Roy, Roy, Roy.
Wieder Magie.
Ja.
Der zweite Pick, den ich mitgebracht habe, ist eine
Bibliothek, die heißt Dramatic oder
vielleicht heißt sie auch Dramatic Q.
Und
das kam auf in einer
Diskussion über, was kann man denn statt
Celery verwenden?
Da gibt es jetzt zwar in Django was.
Die Background-Tasks
hatten wir ja vorhin auch schon kurz gelernt.
Du hast denselben Mastodon-Social-
Thread gelesen.
Ja, offenbar, ja. Und ich habe mir aber die Links
rausgeklickt. Und einer, der mir
ins Auge gestochen ist, war eben Dramatic.
Was auch so ein Queuing-System
ist, was aber ein bisschen
eine pythonischere Syntax hat
als Celery jetzt zum Beispiel.
Und das sah auf den ersten Blick
sehr gut aus und ich freue mich da drauf,
das irgendwann mal
einsetzen zu können.
Ja, stimmt. Habe ich mir auch angeguckt. Das
fand ich tatsächlich nett. Ich hatte noch keine
Zeit und habe mir gedacht, wenn ich jetzt eh noch bis April
warten darf, bis Django Background-Tasks
rauskommt, dann spare ich mir einfach.
Du kannst es auch jetzt schon verwenden.
Ich meine, es ist noch nicht wirklich dafür gedacht, dass man
es jetzt verwendet, aber
Django-Tasks ist ja sozusagen,
kannst du einfach installieren und dann verwenden.
Geht.
Ja.
Warum eigentlich nicht?
Kann vielleicht noch zu wenig, aber
ja. Also, ja.
Also ist auf jeden Fall eine gute Idee, dass
wenn man das noch nicht gemacht hat, einfach mal das
auszuprobieren, weil
dann muss man
nichts mehr umstellen, wenn es dann irgendwann
dazu kommt. Ja, also es gibt so ein paar Module. Wie heißt das?
Django Background-Tasks tatsächlich?
Django-Tasks heißt das Paket.
Genau, weil das habe ich gerade Background-Tasks gesagt, weil das ist
ein fürchterliches Modul.
Und Django-Tasks ist tatsächlich
gut im Vergleich dazu.
Weil Django Background-Tasks gibt es auch und das wird man schwer
wieder loslegen. Ja, ich verlinke das dann, aber
es ist genau, es ist...
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. Ja, wie auch immer. Also Django-Tasks
ist, glaube ich, das, was wir
nehmen wollen. Genau.
Ja, was...
Dann packe ich auch noch mal was. Was ich jetzt...
Ich habe ein... Ich weiß nicht.
Ist auch etwas
Spezielleres, was jetzt gar nicht so viel mit Python...
Du warst einfach nur auf Shopping-Tour.
Ja, aber ich finde
es ganz interessant, weil
ich habe ganz lange jetzt
so Dinge verwendet, wie... Also ich habe auch schon mal...
Also ich mache mal so...
Du hast doch erst Geburtstag, Jochen.
Ja, ja, aber ich brauche es ja
für was anderes.
Ich habe auch tatsächlich irgendwie
mal vor, mal wieder... Also ich weiß nicht, ich schaffe
irgendwie... Ich wollte mal Videos machen.
Mehr wieder. Und dann
da brauche ich dann natürlich auch entsprechendes Equipment,
dafür. Und... Soll ich jetzt demnächst
mal meine Euro-Recksammlung picken?
Ja, ja, mach das. Finde es gut.
Ja, also
wie kriegt man eigentlich quasi Bilder
von der Kamera irgendwie auf den Rechner?
Und ich habe auch schon sowas wie Lightroom verwendet
oder so früher mal. Und dann irgendwann
dachte ich mir, ach, das brauche ich alles nicht mehr. 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 das hat geklappt.
Und jetzt geht das aber nicht mehr, weil
die
RAW-Files, die aus der Kamera rausfallen,
die mag Apple Fotos nicht mehr.
Und... Ich habe meine Kamera gekauft.
Ja. Und
da gibt es aber
dann vom Hersteller, von Nikon
gibt es halt Nikon NX Studio.
Und die kann das... Die Software
kann dann halt tatsächlich das RAW-Format lesen.
Und das Coole ist, und das wusste ich gar nicht, dass das geht,
das
versteht das so gut, dass es
halt irgendwie auch die
die
also quasi Profile für
alle möglichen Dinge aus der Kamera damit drin hat.
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, was bei anderen, bei
Lightroom oder so eben nicht kriegst. 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 du
das halt
wie dein Look halt aussehen soll und so.
Das heißt, du kannst den vorher vorprogrammieren.
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.
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.
Das ist 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... Das klingt als hättest du noch ein neues Hobby. Du hast ja
gerade schon Computerspiele in Rust programmiert.
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 GB weg.
Und dann muss man es neu starten. Was natürlich irgendwie
echt totaler Quatsch ist. Aber...
Hast du nicht genug Speicher, oder musst du neu starten?
Nee, das ist halt alles...
Wieso hast du nur so wenig Speicher, Jochen?
Ich bin nicht nur
GPU-Pur, ich bin auch RAM-Pur.
Ja, nur 32 GB.
Ja, ja, ja. Schon ziemlich lächerlich.
Ja, muss ich auch sagen. Stimmt.
Ja. Aber, ja, genau.
Also da kann man nicht genug... Kann man irgendwie
mit dem RAM-Kaufen nicht hinterherkommen, wenn man halt
Software hat, die einfach irgendwie das
alles wegchrisst. Einfach so.
Ohne Grund. Ja.
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.
Ja. Genau.
Tja.
Ja, vielleicht muss ich doch... Das war jetzt aber schon
ein sehr spezieller Pick, Jochen. Ja, war sehr speziell.
Nochmal, was du bei Fox hat oder so
was machen, wenn wir hier die ganze Zeit nur so
Mediensachen tun,
wie mit den Bildern.
Wir sind ja in so einem Medium
Dings hier auch, ne? Ja.
So Musik,
ja, die Musik, die ich mache, die finde ich meistens
sowieso abartig.
Ja, ich glaube, dann sind wir
für diese Episode tatsächlich
ausnahmsweise mal früh fertig.
Ich habe übrigens zwischendurch Kritik bekommen
auf die Peißen von Leuten, die den Podcast hören.
Es wäre viel zu lang. Es wäre total nervig.
Man könnte es gar nicht mal zwischendurch
durchhören, sondern müsste sich immer so viel Zeit vernehmen.
Man kommt da gar nicht durch. Man hört sich nie zu Ende.
Ja, da müssen wir mal ein bisschen... Also alles, was
wir an weitere Kritikanregungen fragen
und so weiter, hallo at peißenpodcast.de
Bleibt uns gewogen, hört uns weiter. Danke, Johannes,
dass du wieder da warst. Das nächste Mal gerne
wieder vor Ort. Du weißt, das war eine...
Ich komme jedes Mal gerne vorbei,
wenn ich da bin. Ja, wir freuen
uns wieder drauf. Ja, danke, Jochen
und hört uns bald wieder.
Bis dann. Bis dann. Tschüss.
Ciao, ciao.