Transcript: Das Python Importsystem

Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python-Podcast in der Episode Nummer 33.

Die hatten wir letztes Mal ausgelesen. Deswegen müssen wir die Episode Nummer jetzt ergänzen.

Ja, was machen wir heute? Wir wollen heute über Imports reden. Hi, Jochen.

Ja, li, hallo, willkommen Dominik.

Hi, Johannes.

Ja, hallo, ich bin auch mal wieder da.

Ja, wir kennen uns ja alle schon.

Ja, also über das Python-Importsystem wollen wir heute sprechen.

Vielleicht ein paar kleine News vorweg, wie wir das gerne tun.

Und dann gehen wir so ein bisschen in die Details.

Habt ihr News mitgebracht?

Ja, also die einzigen

News, die ich habe, ist, dass Apple sich gerade den

größten PR-Unfug aller

Zeiten einholt. Aber

da ich kein Apple-Gerät habe, geht es

ein kleines bisschen mehr. Das Problem habe ich auch nicht.

Jochen, erzähl du doch mal.

Ja, nee,

tatsächlich ist es PR-technisch, würde ich

sagen, auch aus meiner Perspektive ein großer Unfall.

Wenn man sich jetzt anguckt, was sie

technisch tun, ist es nicht so furchtbar schlimm.

Was ist denn überhaupt passiert? Vielleicht jetzt mal so die Story.

Sie haben irgendwie

War das eine Pressemeldung?

Es war eine Pressemeldung und es war eine technische Meldung, glaube ich,

dass sie jetzt CSAM

angemacht haben, Contact Content Scanning

and

keine Ahnung, was es bedeutet.

Ja, jedenfalls

wollen sie, jedenfalls will

Apple jetzt in die Fotos reingucken und

verbotene Inhalte finden.

Ja, das ist natürlich

so ein bisschen, das, ja.

Mit modernster Technologie.

Ja, zum Glück

ist es nicht das Schlimme.

und Technologie, was man halt auch nehmen könnte,

sondern es ist halt irgendwas total Billiges,

einfach nur Hashes in Bildern angucken.

Also im Grunde nur gucken, ist das ein

Bild, das auf irgendeiner Liste draufsteht

von verbotenen Bildern.

Ja, aber haben die nicht auch gesagt, dass sie so

neuronale Netze drüberlaufen lassen

und dann Sachen erkennen wollen?

Oder ist das erst der nächste Schritt?

Ja, genau, das ist halt der

Agau-Teil. Ja, genau, und das ist auch so ein bisschen

der Präzedenzfall.

Früher war Apple ja immer so, ja,

es ist auf deinem Gerät und es ist alles sicher und wir können

da gar nicht. Und jetzt ist es so, ja, wir gucken doch mal rein.

Ja, also

entweder war es ein Unfall,

sozusagen, dass jemand nicht drüber nachgedacht hat,

dass, wenn man das so sagt, dass das dann genau

das auslöst bei den Leuten.

Oder es ist halt irgendwie, aber das kann ich

mir auch nicht vorstellen, weil das wäre ja so

ein abrupter Strategiewechsel. Das wäre auch schon

irgendwie komisch. Also insofern nehme ich mal an,

dass es eher ein PR-Unfall ist.

Man weiß es nicht. Aber es ist ein

Präzedenzfall. Apple scannt jetzt Inhalte

auf euren Geräten.

Das machen sie

Das machen sie ja auch sowieso schon immer.

Also man kann ja auch in der Fotos-App

irgendwie nach Hund gucken

oder nach Personen oder sonst irgendwas.

Und da ist tatsächlich, das ist halt die gute Technik

sozusagen, die da verwendet wird.

Und ja, man kann sogar...

Aber auch da sind viele Sachen falsch einsortiert.

Ja, aber sie sind da auch

halbwegs schnell und so. Man kann auch nach

Vaccination oder so suchen und dann findet es den Impfpass,

wenn man den fotografiert hat und so.

Also da machen sie auch wirklich das gute

Zeug.

Und machen das halt

auf dem Gerät selber.

Aber genau, nur halt, wenn man selber sagt, man hätte das gern und ja, und halt, es wird auch nicht an irgendwen geschickt. Und jetzt ist das natürlich eine andere Sache, wenn sie jetzt irgendwas eines von den verbotenen Bildern findet, dann sagt es irgendwie dann Petzl.

Vielleicht verbotene Bilder?

Ja, wer weiß.

Genau, und wir wissen auch, dass es da welche gibt, ja. Also das ist natürlich alles sehr unangenehm und das wäre dann schon ein Präsenzfall, weil das haben sie bisher nicht gemacht.

Na gut, mal sehen, wie sich das entwickelt. PR-mäßig ist es auf jeden Fall ein mittleres Resultat.

und das ist von einem Impfpass gesagt, das heißt, du bist auch jetzt durch.

Ich bin schon lange durch.

Ich auch jetzt seit einer Woche.

Also hier auch nochmal der Aufruf von allen Zuhörern, lasst euch bitte impfen.

Ja, das ist eine gute Idee.

Wie viele haben wir jetzt verloren?

Die Zuhörer.

Es gab so einen tollen Rant-Post von Linus Torwalser.

Ja, der sagt auch, lasst euch impfen, ihr Trottel.

Ja, genau.

auf der Tour.

Ja, Linus Torwalds

benutzt noch mehr ausgewählte Wörter,

um das zu beschreiben, sagen wir es mal so.

Ja, aber inhaltlich

doch. Inhaltlich war es die Zusammenfassung, ja.

Ja, haben wir noch Python-News?

Ja, also eine

News, die so ein bisschen anschließt an

unsere letzte Episode zu Packaging,

ist, dass tatsächlich,

das war vielleicht schon länger klar,

aber mir war es halt noch nicht klar, ab

Python 3.11

wird Distutils

halt deprecated.

Und das heißt,

man muss sich da an der Stelle dann halt mal was überlegen,

was man dann so tut.

Aber es gibt doch so viele Alternativen.

Ja. Diverse Alternativen.

Also die

Pakete, die jetzt halt so

ein richtiges Problemchen bekommen,

sind halt sowas wie

NumPy und SciPy und so, weil

die haben nämlich, die erben nämlich von

Distutils und haben da Extensions für gebaut

und damit bauen sie halt alles.

Ja, okay.

und ja,

also die gucken sich gerade andere Sachen an

und

tatsächlich gibt es da, also sie haben sich zum Beispiel

CMake angeguckt oder halt auch

Mason heißt das irgendwie

und tatsächlich

also ich manchmal, also sogar relativ

häufig, ich habe ja hier so ein M1

Mac auch und da passiert

es durchaus, also wenn die Python-Version hochgeht oder so,

ist es eigentlich immer so, dass wenn ich dann

Projekte habe, die

abhängig haben zu NumPy,

Pandas oder so, dass das Ganze zwar kopiert werden muss,

weil meistens ist das Update von Python halt schneller bei mir, als die Wheels draußen sind.

Und dann muss ich das halt kompilieren und dann denke ich mir so, oh nein, jetzt dauert das wieder ein paar Minuten.

Und tatsächlich dauert das bei NumPy, glaube ich, sieben Minuten irgendwie mit dem klassischen jetzt des Tutels.

Und tatsächlich aber auf Mason basierten, hat hier jemand schon den Namen vergessen, angefangen damit rumzuexperimentieren, dauert es halt irgendwie noch vier Sekunden oder so.

Also es ist hauptsächlich irgendwie

Bauzeit,

die da

benötigt wird.

Also insofern, mal gucken.

Könnte sein, dass es alles schneller wird demnächst.

Das wäre auch ein sehr positiver

Effekt von dieser Deprecation.

Genau. Und ansonsten,

ja, ich glaube 3.11

ist in der Beta.

3.10 ist in der Beta.

Ich glaube, jetzt um den Dreh

ein Rieskandidat.

Genau.

Die Zahlen gehen so schnell hoch.

Ja, ja, ja. Freuen wir uns schon.

Also ich habe mal den GitHub Copilot,

den wir auch schon mal kurz erwähnt hatten, ausprobiert.

Da habe ich jetzt auch eine Beta-Einladung bekommen.

Muss sagen, das ist echt toll.

Also ich habe noch nie so einen

super Effekt von einer KI erlebt.

Ich finde es echt nice. Ich gebe ein, also ich habe

jetzt die VS Code Extension dafür benutzt.

Sowas wie Define and Fibonacci oder sowas.

Und dann warte ich

auf das Autocompletion und dann schreibt er mir die komplette

Funktion inklusive Docstrings und Type Annotations

als Type-Int und ich drücke einmal

Tabulator und es ist fertig. Und das geht

halt auch für Sachen, die ich selber schreibe. Wenn ich jetzt

eine Klasse schreibe, verschiedene Methoden nehme, beispielsweise

irgendwie HTTP-Methode.

Ich habe jetzt irgendwie ein Get geschrieben, ne, in einer Klasse.

Define, Get, bla bla bla. Und danach

fange ich an mit Define und dann steckt er mir

als nächstes vor, Post zu definieren.

Und zwar auch mit genau den richtigen Parametern und so.

Das sind solche Sachen, das ist halt einfach,

der lernt halt aus seinem eigenen Code raus und das ist

wow. Also ich bin wirklich beeindruckt davon,

was das so macht. Also das ist so ein bisschen,

man braucht keine Snippets mehr, ja, wenn man irgendwie

Snippets-Sammlung hat, sondern man nimmt halt einfach dann

das individualisierte Snippet und das ist

und Jochen unterhalten sich über die Programmiersprache Python

Modelle trainiert werden?

Nein.

Das ist halt etwas, was sich allmählich einbürgert.

Der Begriff dafür nennt sich

Self-Supervised Learning.

Und zwar deswegen, weil man halt

zum Beispiel auf Text

relativ gut Modelle trainieren kann,

ohne irgendwelche gelabelten Daten

haben zu müssen. Was man ja normalerweise ist, ist immer das Problem

bei

irgendwie, wenn man so überwachte

Modelle, also

anführungsweise normale Machine Learning Modelle

trainiert, dann braucht man halt Trainingsdaten

und damit meint man üblicherweise halt

Daten, wo man

Labels dran geschrieben hat, wie zum Beispiel

jetzt, wenn man jetzt Bilder hat, so was ist ein Hund, das ist eine Katze

und das ist, weiß ich nicht, irgendwas

dazwischen oder so

und

bei Texten hat man das ja auch,

da gibt es dann ein klassisches Problem wie Textkategorisierung,

da hast du halt einen Text und dann steht halt zum Beispiel so

diese Newsreuters-Artikel, da steht dran,

das ist jetzt Sport oder das ist Politik oder das ist halt irgendwas anderes

und

und... Cool wäre ja so das Label wie, will ich lesen, will ich nicht lesen?

Kann man auch alles machen.

Wenn du da Trainingsdaten hast, dann kannst du Modelle drauf trainieren, die dann auch wahrscheinlich

halbwegs gut funktionieren sollten, also das geht alles. Aber das Problem ist

natürlich, dass für die meisten Probleme, die man so hat, hat man halt eben keine Trainingsdaten und das

Erstellen von Trainingsdaten ist halt so aufwendig, dass sich das dann meistens nicht lohnt, das zu machen.

Wie viel braucht man denn da, ungefähr 100.000? Also kommt drauf an, wie gut es sein soll.

und dann entsprechend

unter Umständen schon Millionen von Beispielen oder so

und das ist dann halt doof, weil das ist einfach zu viel.

Die meisten Leute haben so viele Beispiele gar nicht.

Nee, genau. Also einmal, du hast

gar nicht genug Beispiele, um sie labeln zu können,

dann musst du die erstmal besorgen, dann musst du es auch noch irgendwie labeln

und dann hast du Fehler in den Labels, weil

halt die Leute das nicht perfekt gemacht haben und dann

musst du das irgendwie kontrollieren und

dann schwuppdiwupp hast du irgendwie so ein Redaktionssystem

und eine Redaktion, eine technische Redaktion

und dann Prozesse und

keine Ahnung und Abstimmungen und das kostet

Schweinegeld und das macht dann halt keiner so einfach so.

Sondern nur, wenn man es halt wirklich, wirklich braucht.

Und

ja, aber

man kann halt aus Text auch

lernen, ohne diese ganzen Geschichten

haben zu müssen. Also

es gab ein Paper 2017,

ist das glaube ich irgendwie, Attention is all you need.

Da wurde halt diese Transformer-Architektur

eingeführt und

diese

Dinge funktionieren auf Sprache halt total super.

die funktionieren so,

und Jochen unterhalten sich über die Programmiersprache Python

in die Richtung, dass es das halt beim nächsten Mal besser macht.

Und das machen wir dann ganz oft

und dann kann es halt

aus einem Text, ohne dass man da irgendwelche Labels

explizit für bräuchte oder so,

Dinge lernen, und zwar fast alles.

Und das ist halt das Interessante.

Man kann das gesamte Internet nehmen

und dann lernt es halt

lustigerweise eben nicht nur

irgendwie so stumpf, welches Wort

die höchste Wahrscheinlichkeit hat,

dazustehen, sondern um das gut machen

zu können, lernt es halt auch eine ganze Menge

Konzepte und wie Dinge in Verhältnissen

stehen und solche Sachen. Auch Kontext tatsächlich,

das ist halt spannend. Also zum Beispiel

das Plugin schafft das halt auch,

Kommentare richtig zu schreiben. Das heißt, ich fange

mit einem Kommentar an, zwei Worte, und das macht

einen relativ guten Vorschlag für, was da stehen sollte.

Ja, ja, ja, genau.

Das ist eine

Geschichte, die man halt auch machen kann, dass man sagt,

okay, das ist ein Text, der Rest ist halt Lücke,

dann füll mal. Und dann kommen da auch

schon ganz interessante Geschichten bei raus.

Also wenn man sich diese generierten Texte

anguckt, dann ist halt schon immer so, dass man

irgendwann wird so leicht absurd oder

sehr verdreht irgendwie und

merkt so, okay, so ganz, schon so ein bisschen

neben der Spur. Ja, man kann es halt schnell kaputt machen.

Ja, die nähern dann auch so ein bisschen.

Wenn man halt so ein bisschen nicht falsch ist.

Kann man es schnell kaputt machen,

dann kann es immer so. Ja, ich habe noch

was dazu gelesen,

was in eine andere Richtung geht, dass es jetzt

wohl eine große Anzahl inzwischen von

wissenschaftlichen Veröffentlichungen gibt,

denen man durch Analyse

ansehen kann, dass eben nicht von

im Menschen geschrieben würden, sondern von einem neuronalen Netzwerk.

Und die Technik,

die die da verwendet haben, die ist total witzig,

weil diese Netzwerke für

so Paper-Generierung

und für Text-Generierung generell,

die werden wohl bestraft, wenn sie Plagiate

erzeugen. Weil das willst du natürlich nicht.

Du willst natürlich nicht ein Paper einreichen, das dann als Plagiate

abgerichtet wird. Und deshalb

wählen die sehr viele Synonyme.

Die sprechen sehr viel in Synonymen.

Und auch eben so Fachbegriffe

werden dann oft in Synonymen

genommen. Das nette Beispiel,

was ich erkenne, war eben, dass da die Paper

über Big Data, die haben die ganze Zeit über

Colossal Information gesprochen.

Was eben kein normaler Mensch

schreiben würde. Und dann haben sie eben gesucht, wie oft

dieser Begriff

Colossal Information in den Papern

vorkommt und die dann eben genauer

angesehen und die hatten eben

alle diese Anzeichen von erzeugten Papern.

Und das ist so ein bisschen jetzt quasi

die Kehrseite von Copilot, dass die eben nicht

nur, man muss es dann trotzdem noch für was

Gutes einsetzen und nicht für

Ja, du bist ja schon

da, du brauchst Pages beizutreiben.

Ja, aber

genau, was ich

noch erwähnen wollte, war,

genau, man kann jetzt halt sozusagen Modelle trainieren

auf allen Texten, die es im Internet gibt

und die lernen halt tatsächlich da auch

Dinge dann raus und das ist natürlich total super und das geht

bei Sprache vor allen Dingen deswegen, weil

man halt eine endliche

Anzahl von möglichen

Füllern

sozusagen für die Lücken. Was? Noam Chomsky

würde dir widersprechen, Jochen?

Ja, ja gut. Aber man kann sich da ja beschränken.

Man kann ja sagen, okay, meine Sprache hat nur

20.000, 30.000

Vokabeln

und das war's. So größer ist mein Vocabulary

einfach nicht. Ja, okay. Und wenn du immer nur ein Wort

rausnimmst, ist natürlich klar. Und unter denen

wird auch eins sein, das hinreichend nah dran ist.

Und dann kannst du eben allen Worten

eine Wahrscheinlichkeit zuweisen. Du kannst halt sagen,

okay, das ist jetzt sehr, sehr unwahrscheinlich

und das ist jetzt irgendwie, dass das geht.

Das sind alle sehr unwahrscheinlich.

Es gibt dann bestimmt das Wort wie F, das was überall hinpasst.

Ja klar.

Aber das Modell,

das dann halt auch, das Modell, das

damit trainiert wird, passt dann aber nicht mehr überall hin, wenn du das

als akzeptiert hast.

Kennen wir leider.

Jedenfalls, genau.

Also mit Sprache geht das

total super und eben

Copilot ist halt dann

quasi auch eine Folge. Das Tolle ist, dass man

jetzt. Modelle, die da drauf trainiert sind,

kann man jetzt mit ganz wenig Trainingsbeispielen

auf das

Problem, das man wirklich hat,

adaptieren. Also da braucht man dann nur noch

ein paar Trainingsbeispiele, also

nicht mehr viele. Ja, ich glaube auch,

er macht das tatsächlich anhand des Repos,

was du gerade auffasst. Kann er schon gucken

und kann da schon dann die Completion zum Beispiel oder die

Vorschläge anpassen auf das, was du da gerade machen

willst. Und das ist schon echt wow.

Ja, und das ist halt natürlich total toll, weil

das dann halt läuft,

dass du im Grunde dieses Trainingsproblem

Trainingsdatenproblem loswirst.

Und ja,

eine ganze Menge Anwendungsfälle

plötzlich von, ist zu aufwendig,

unlösbar, lohnt sich nicht, in Richtung

kann man schon mal probieren,

wandern und dann ist es natürlich toll.

Und ja, also da wird es

eine Menge interessante Anwendungen geben.

Also gerade für die ganzen V-Programmierer unter uns, also das ganze

Zeug drumherum, das geht halt einfach jetzt viel

automatisierter.

Ja, Kinderregegen, das ist schlecht für die

Auftragsprogrammierer.

Das finde ich nicht gut.

Das kann schon sein.

Ja.

Aber genau, das Problem

ist aber jetzt, dass man das nicht

machen kann für, also was halt, also

man würde, wäre sehr viel weiter,

wenn man das jetzt auch für zum Beispiel

Bilddaten machen könnte. Also und

tatsächlich ist es wohl so, dass es da

gibt es auch inzwischen Forschung zu,

das ist halt tatsächlich der Weg, also man hat sich ja das

oft lange, oder ich erinnere mich noch dran,

dass es mal völlig unklar war, wie das

eigentlich funktioniert, wie lernen Kinder eigentlich

sozusagen so schnell Dinge, man versteht es nicht, sie sehen eigentlich zu wenig Trainingsbeispiele

für das, was sie da lernen und tatsächlich lernen sie ja auch so etwas, was einem die

Forschung sagt, manchmal Schwierigkeiten hat, das einfach so zu akzeptieren, aber die sagt

halt, das meiste, was Menschen so lernen, lernen sie halt so in den ersten neun Monaten

und alles, was danach kommt, ist halt so, naja Gott, also ich meine so Details, also

Die wesentlichen Dinge sind bis dahin gelernt.

Wie machen die das denn?

Kinder in dem Alter verstehen einfach gar nichts.

Die kennen auch keine Worte für nichts.

Wieso können die denn so viel lernen?

Wie soll das gehen? Das ist irgendwie alles seltsam.

Und tatsächlich ist es wohl so,

dass die halt auch schon eine Art

Self-Supervised Learning machen

und quasi genau das gleiche Prinzip irgendwie

sehen halt was

und Dinge passieren

und dann betrachten sie das

sozusagen als eine Art Lückentext und füllen das dann halt

und das funktioniert.

Genau, das ist das Ego, was das dann macht

Na, keine Ahnung

Ja, aber das zieht das dann irgendwo aus dem Äther, irgendwelche

Formationen schafft das dann natürlich und deswegen hast du ja auch

so, weiß nicht, ob ihr das kennt, wenn ihr irgendwo

müde seid oder sowas, dann werden bestimmte Sachen

ja auch einfach ersetzt, der Kopf macht das ja sehr gerne

dass er bestimmte Flecken, die

nicht so ganz klar sind, dann mit Sachen überschreift

also einige Leute, die haben dann auch

innere Stimme, die dann auf einmal das erste Mal vollständig

die nur so halb gehört haben oder

das kannst du auch mit optischen Informationen machen oder mit

anderen optischen Signalen

und das ist halt super spannend tatsächlich

und wenn das halt self-supervised learning ist,

dann ist ja auch klar, dann hast du so ein Lückenbild.

Das ist so ein bisschen so, du hast ein Foto,

da fehlt ein Teil und dann wird das automatisch ersetzt.

Das ist spannend, wenn die KI das kann, dann kann man

quasi, machst du ein Hochzeitsbild von dir, dann kannst du irgendwie

deinen Partner rausschneiden, dann kannst du den idealen Partner auf einmal sehen.

Ah ja, und

so ist also dieses Python

Import-System entstanden.

Das ist ja spannend.

Wie, willst du jetzt zum Topic zurück?

Nein, nein. Nur ganz kurz, also

das, was halt momentan nicht geht, was man nicht

hinkriegt und was halt total toll wäre, wenn man es irgendwie hinkriegen würde,

also vielleicht hat ja irgendjemand eine Idee

das große ungelöste Problem an der Stelle ist halt

wenn du jetzt ein Bild aus einem

Teil aus einem Bild rausnimmst und sagst so

das ist jetzt leer, also einmal

man kann halt irgendwie die

Menge an Bildern, die halt an der Stelle möglich wären

nicht aufzählen, nicht so richtig

und dann ist es so

selbst wenn man sich irgendwie beschränkt

weiß man nicht, so jetzt hat man

zwei Sachen, die eigentlich offensichtlich nichts damit zu tun haben

mit dem Bild, das man eigentlich an der

Stelle gerne hätte, welche Wahrscheinlichkeit weiß man

hinzu und wie ist der Gradient in welche Richtung.

Aber vielleicht braucht man da den Kontext für, weil wenn du einen Kontext

hast, in dem das drumherum gestellt werden soll,

der halt selber ein Objekt ist,

das viele verschiedene Informationen beinhaltet, dann ist es

besser, diese Menge an

abzählbaren Elementen zu bilden und das entsprechend

herauszusuchen mit der höchsten Wahrscheinlichkeit.

Das heißt also, ohne Kontext ist das wahrscheinlich nicht so

einfach möglich, dass du einfach so ein Bild machst, das dann gut trifft.

Aber wenn du Informationen über den Kontext hast,

in dem du dieses Bild ersetzen möchtest...

Also der Punkt ist eher, das ist ja möglich.

Also du kannst ja durchaus ein Modell trainieren,

was dann irgendwas vorhersagt an der Stelle.

Die Frage ist nur, welchen Wert hat das, was es jetzt vorhergesagt hat?

Hat das jetzt die Wahrscheinlichkeit 0,376 oder 0,652?

Und das macht ja einen Unterschied fürs Training, aber es ist halt völlig unklar, wie man da die Wahrscheinlichkeit ausrechnen soll.

Ja, vielleicht braucht man dafür echt einen Kontext, in der es eingesetzt werden soll.

Das ist, glaube ich, gar nicht so.

Ja, also das ist auf jeden Fall, wenn da jemand eine Idee hat, voll gut.

Aber das war jetzt auch gerade wieder so ein Ding, was halt passiert, wenn man halt den Kontext nicht hat.

dann passiert sowas wie ein Relative Import

Beyond Top Level Package oder so.

Oh, das ist ein Syntaxfehler quasi.

Ich sehe schon, es gibt eine gewisse

Abschüssigkeit in eine

bestimmte Richtung. Ja, Importsystem ist auch

voll interessant. Na gut.

Ja, natürlich, das war gerade ein

Versuch, da so ein bisschen hinzukommen, weil wir wollten ja über das

Importsystem tatsächlich reden und

wie man das in Python macht.

Und ich glaube, als Basis irgendwie das so ein bisschen zu verstehen,

es gibt einen super tollen Blog, den ich auch erst letztens

entdeckt habe, der 10.000 Meters heißt,

der irgendwie auf Hacker News nochmal gefeatured worden ist und da hat ein

Mensch namens Viktor Skvorstov, wenn ich ihn richtig ausspreche,

einen Artikel geschrieben, wie das Python-Import-System funktioniert.

Und das hat er so ein bisschen erklärt, das ist sehr spannend zu lesen.

Fangen wir auf jeden Fall in die Shownotes. Und ja, wie funktioniert denn das eigentlich?

Was ist denn das Python Ja ich habe diesen Artikel auf Hacker News gesehen und auch die Diskussion dann so ein bisschen angeguckt und da ist mir aufgefallen dass das doch tats erstaunlich

viel komplizierter ist, als

man das so denkt oder als man das im Kopf hat.

Was mir gar nicht so aufgefallen

war, weil ich offenbar

nicht alle Features benutze, die es da so gibt.

Vielleicht ganz kurz, bevor wir darauf einsteigen,

was ist denn überhaupt das Problem damit?

Wir haben so eine Story gehört, dass das mal lange

macht, was macht denn das?

Worum geht es denn da überhaupt?

Und warum braucht Python ein Import-System überhaupt?

Das ist ja auch eine spannende Sache, weil in anderen Sprachen ist das ja anders

gelöst und zum Teil besser und zum Teil

schlechter.

Wer will

anfangen?

Ich würde sagen, vielleicht kann man genauso anfangen wie der Artikel.

Was passiert denn, wenn man sagt Import M?

Warum sagt man das denn überhaupt,

Jochen?

Es gibt

natürlich Build-Ins, aber nicht alles sind

Build-ins und manchmal möchte man halt

irgendwo Funktionen oder Klassen oder sonst

irgendwas verwenden.

Oder man möchte einfach seinen Code trennen

und nicht alles in eine einzige Pfeile.

Man möchte halt irgendwas verwenden, was nicht in der aktuellen Datei definiert ist.

Genau.

Und jetzt könnte ich verschiedene Dinge,

ich könnte mir die Datei nehmen und sie

e-ballen, könnte ich machen.

Ja.

Wäre

auch möglich, oder?

Wäre auch möglich.

Hat auch einen ähnlichen Effekt irgendwie.

tatsächlich. Aber das

überschreibt dann natürlich manchmal Sachen, wenn ich jetzt irgendwie

zum Beispiel da drin halt,

wenn ich jetzt im aktuellen... Ja, vor allem, wenn man das rekursiv

macht, weil das müsste dann auch immer weiter funktionieren.

Ja. Und dann

wenn man so Counter-Variablen hat oder so,

die sind dann wahrscheinlich hinterher anders.

Vielleicht, ja. Vielleicht. Ja, oder auch

Namen, die einfach gängig sind,

werden vielleicht eventuell überschrieben.

Ja, aber das ist ja, bei Python macht der auch

irgendwie sowas, ne? Das macht ja so ein

Namespace wieder. Ja, genau. Aber das müsstest du dir

dann, also wenn du einfach die Datei lädst

und ausführst, also

e-Val drauf machst, dann

ja, kriegst du halt erstmal alles in die Hand.

Und da wäre dann, hätte man

dann auch wieder das Problem mit dieser Dekursion, die müssen wir auch irgendwie

lösen, weil du musst ja dann eventuell noch mehr Sachen

derweil

importieren und e-Valen und

vielleicht hast du ja sogar das Problem, dass

du es zyklisch machst.

Aber das Problem haben wir in Python auch.

Das Problem haben wir in Python auch, ja, aber

müssen wir mal überlegen, wie das das macht.

Aber in anderen

Sprachen, um da noch kurz drauf anzugehen,

braucht man es ja, macht man es ja

nicht. In Java oder in C++

macht man es ja nicht, dass man einfach

andere Dateien da reinkopiert,

weil da ja

die Organisation anders ist. Da braucht man ja quasi

keine Objekte in der Hand, sondern nur

einen Verweis auf die entsprechenden Stellen

im Code. Das heißt, bei denen

funktioniert das Import-System halt,

weil das während des Kompilierens passiert,

deutlich anders

als in Python.

Ja, ich überlege gerade, wo da die Unterschiede sind.

Also wenn ich in C sage include,

das wäre das eine Datei.

Genau, aber wenn du zum Beispiel in C

includeierst, die sind ja normalerweise nur .h-Dateien.

Und da sind ja keine Definitionen drin,

da sind ja nur Deklarationen drin.

Da steht nur drin, es gibt etwas, was heißt so und so.

Und das ist das Einzige, was du an der Stelle da reinkriegst.

Das Zusammenführen, was dann tatsächlich der Code ist

oder was diese Werte sind. Das passiert erst später

im Link-Vorgang, wenn

du schon alles kompiliert hast. Und diese

Phasen gibt es bei Python ja einfach überhaupt

nicht. Bei Python gibt es ja nur die Phase

Ausführen. Und zu dem Zeitpunkt

brauchst du es dann jetzt. Und

was viele Leute vergessen,

wenn du define schreibst, wenn du eine Funktion definierst,

wenn du eine

Funktion erstellst, dann ist

das Code, der ausgeführt wird, das ist ein Befehl

an Python und der heißt,

merkt ihr mal unter dem Namen, keine Ahnung,

fun, ein Code,

Objekt, was folgende Eigenschaften hat.

Es ist callable und dieser callable hat

folgende Parameter und dann steht da

Code drin und so weiter und so fort. Und auch

bei Class, wenn du Class

als Schlüsselwort, wird ja erstmal

alles ausgeführt, was da drin ist. Das heißt, du kannst da

prinzipiell Code drin haben, der

Sachen tut, was ja auch an vielen Stellen

sehr wichtig ist, was du aber in anderen

Systemen nicht hast.

In der Java und in der C++

hast du das nicht, das wird nicht ausgeführt.

Es wird zum Teil ausgeführt

bei C, weil du da diesen komischen Preprocessor

hast und weil der auch so

constant optimizations

versucht schon mal zu machen,

aber generell wird

C-Code erst ausgeführt, wenn du das Programm startest.

Das ist bei Python,

ja, also diesen Schritt des Kompilierens gibt es ja bei Python

nicht, der ist ja da so ein bisschen innen drin.

Das heißt, du kannst auch mit Import

kannst du auch Sachen ausführen.

Was

manchmal komisch ist und manchmal gewünscht

und manchmal überraschend.

Ja, also das ist manchmal,

also tatsächlich, wenn Sachen importiert

und das dann halt alles in dem Modul ausgeführt wird,

was auf dem Top-Level ist, das ist halt schon

manchmal eher überraschend.

Warum passiert das denn auch?

Warum wird das dann ausgeführt? Also wenn man jetzt

einen Import hat, Import M

von irgendwo, was dann...

Einfach nur Import M, also wirklich nur

diese Zeile Import M. Was passiert dann?

Ja, das ist eine gute Frage.

Und auf den ersten Blick ist es

finde ich so ein bisschen offensichtlich, was da passiert

und auf den zweiten Blick ist es dann tatsächlich doch nicht so offensichtlich,

wie eben dieser Artikel,

glaube ich, uns allen demonstriert hat.

Also für mich bedeutet Import M

suche eine Datei,

die M.py heißt

und gib mir den Inhalt

davon als Modul. Oh, das wäre aber ein Skript.

Und wir könnten auch ein Modul laden.

Wenn ein Modul heißt, das M heißt,

das ist ein Verzeichnis oder sowas.

Aber ein Verzeichnis ist ja

auch nur so eine Art Datei.

Ein Verzeichnis ist ja auch nur ein

Verweis auf die Init.py.

Es gibt Module und Packages

und was ist denn überhaupt der Unterschied?

was ein Skript, was ein Modul, was ein Package.

Ja, das ist schwer zu sagen.

Ich finde es schwer zu sagen, weil

für mich dieser Unterschied wirklich minimal

ist. Das eine ist halt

eine Datei und das andere ist ein Verzeichnis, aber das Verzeichnis

selber hat ja keinen Inhalt

und deshalb tut man so, als ob die InitPy,

die da drin ist, dass der Inhalt dieses

Verzeichnisses ist.

Genau, in der InitPy kann man auch

sowas wie all dann definieren, das heißt, wenn man zum Beispiel sowas wie

import as quick, dann kannst du auch eine einzelne

Datei machen. Kannst du überall definieren.

Ja, okay.

Kannst du auch Slots definieren, das ist auch, kannst du auch überall machen.

Ein Slot? Ja, das sind solche Sachen, die beim Import mitgebracht werden sollen.

Genauso wie All, wenn du All definierst und dann machst du From M Import Stern, dann kriegst du alles das, was in All drin steht.

Also Unterstrich, Unterstrich, All, Unterstrich, Unterstrich, um es jetzt mal hier korrekt zu sagen.

Dann, dann, All, dann, dann.

Das ist ein sehr guter Mechanismus, den sieht man sehr selten, weil Importsternen ja so verpönt ist, so gerne gesehen wird. Das hatten wir schon in der ersten Vorlesung quasi in Informatik 1, hat uns unser Professor schon gesagt, ja man kann using namespace standard nehmen und dann kann man mal gucken, wie viele Symbole da importiert werden und es waren irgendwie 13.000 oder sowas.

und das kannst du in Python natürlich auch machen,

kannst auch from Stern import Stern

probieren,

kriegst halt auch 100.000 Sachen rein.

Deshalb ist

import Stern,

nee, nee, from Stern import Stern geht nicht,

aber so quasi, wenn du es dir

vorstellst. Import Stern heißt halt,

hol alles aus diesem Modul oder aus dem Package

und gib es mir

und meistens weiß man ja gar nicht

ganz genau, was da drin ist. Meistens weiß man auch nicht,

wie viel da drin ist.

Und ganz oft sind da ja dann

auch lokale Sachen drin, die man eigentlich gar nicht haben

möchte. Oder Imports, die

dieses Modul macht,

die hast du dann auf einmal auch selber

importiert. Subdependencies quasi.

Genau, also wenn du in

der m.py, so wie wir es jetzt eben

drin hatten,

wenn du da import, keine Ahnung, import

x machst, und dann machst du from m

import Stern, hast du auch x importiert.

Weil das halt in dem

Modul m dann schon drin ist. Und das ist genau

der Grund, warum man dieses Stern nicht machen soll, weil man nämlich

nicht weiß, was da drin ist und man halt dann alle...

schon gab, bei einem Lokal irgendwo

überschreiben würde. Und wenn mehrere

Module oder Pakete

dasselbe Namen definieren

für irgendwas, was ja durchaus mal vorkommen kann,

dann weiß man nicht mehr genau, was unter dem Namen jeweils

Identität ist. Aber jetzt müssen wir ja erstmal klären,

was Import überhaupt macht. Wir sprechen

jetzt schon die ganze Zeit so, aber wir wissen es immer noch nicht.

Wir wissen aber immer noch nicht genau, was ein Modul, ein Paket ist.

Ja, also ich glaube,

das eine ist eine Datei und das andere ist

ein Verzeichnis.

Es gibt eine Datei.

Ich glaube, es ist auch irgendwie...

der Datei.

Ich glaube, der entscheidende Unterschied ist, dass

ein Paket Submodule haben kann

und ein Modul nicht.

Also genau, ich habe

eine Definition gefunden,

der irgendwo sagt hat, if a module name

has no dots, it's not considered to be part

of a package.

Aha.

Ja, okay.

Also ein Paket ist

quasi eine Sammlung von Modulen oder sowas?

Ja, okay, gut.

Ja.

Da gab es auch eine tolle Antwort drin, Relative Imports for the Billions Times oder sowas.

Ja, relative Imports, darüber muss man auch noch sprechen. Ich bin ein großer Fan davon, aber offensichtlich nicht so. Gut, da kommen wir vielleicht nach.

Ja, ja, ja, okay.

Also was macht denn Import jetzt überhaupt? Import macht, soll ich mal versuchen, soll ich mal mein Verständnis erklären und er korrigiert mich dann.

Von wo importiert ihr denn überhaupt?

Genau, also Import. Erstmal sucht Import ein, also wenn ich sage Import M, dann sucht das Import-System von Python nach etwas, das M heißt. Und zwar auf dem Python Path.

Auf dem Python Path. Ah.

eine Variable, die heißt

sys.pythonpath

sys.path heißt die, oder?

Ich weiß, ich vergesse es jetzt mal wieder.

Jedenfalls ist da eine Menge

von Verzeichnissen drin und

in der Reihenfolge, wie sie in diesem

Path stehen, wird nach

dem Namen

M gesucht. Also 0 ist glaube ich der aktuelle

irgendwie, dass das

entweder vorne oder hinten, das ist immer

Ich glaube 0, der erste ist immer der, wo du gerade bist.

Punkt. Genau.

also die Datei, wo du gerade aufgeführt bist

oder sowas und dann ist halt quasi, der sucht halt dann

im ersten in 1, wo und ab da

und der erste Hit wird dann genommen

Genau, der erste Hit wird dann genommen und in diesem Path

können ganz viele verschiedene Sachen

drin sein, also die Installation

des Installationsverzeichnisses des Interpreters

und wenn man irgendwelche

Environments aktiviert hat, dann sind die da alle drin

man kann da auch selber Sachen reintun

braucht man manchmal, ist manchmal ganz nützlich

Also wenn man verschiedene Pakete

haben will, die auch importiert werden können

dann muss man einfach da gucken, dass

in this.path quasi in der Umgebungsvariante

Das ist im Wesentlichen das, was

VirtualEnv macht. Er macht ein Verzeichnis, wo

du deine Pakete reinlegen kannst und tut den

in den Python-Path für dich. Genau, das heißt, wichtig,

dass euer Path vernünftig konfiguriert ist, wenn ihr Python nutzt,

weil wenn die falsche Reihenfolge drin ist, dann kann

das sein, dass er im Path von Python

2 sucht oder so, also wie es

früher offenbar war. Und dann habt ihr ein Problem.

Genau.

Also, und er sucht diese ganzen Verzeichnisse durch

und wenn da irgendwas drin ist, was diesem Namen m entspricht,

also eine m.py oder ein Verzeichnis, was m

heißt, was eine InitPy hat, oder

in Python 3 ein Verzeichnis, was

das M heißt und Python-Dateien

enthält, was keine InitPy hat,

dann wird

das als Modul importiert

und in den aktuellen Namespace

als Modul M übergeben.

Wir haben gerade wirklich das schon in Python 2 und 3 diskriminiert,

das ist ja interessant. Ja, da gibt es Unterschiede.

Ja, da gibt es auch interessante,

also nochmal ein sehr interessanter Unterschied

kommt mit Python 3.3

glaube ich dazu, nämlich die Namespace-Only-Pakete.

Erklär mal.

Die gibt es.

Früher musste man ja immer die InitPUI haben.

Vor allen Dingen deswegen,

damit halt nicht Verzeichnisse,

die halt so heißen wie ein Standardmodul,

das Standardmodul überschreiben.

Und man halt damit dann

quasi öffentlich

sich dazu bekennt, dass das jetzt ein

Paket sein soll.

Also sozusagen, wenn man sich den Infus

schließt, dann muss man das auch wirklich absichtlich gemacht haben.

Und das ist aber

teilweise blöd.

weil oft will man vielleicht auch

Dinge, die in einem Paket liegen, nicht in einem

Verzeichnis haben zum Beispiel.

Und also wenn es

ein InitPy gibt, dann

ist das

ja dann, jetzt weiß ich

nicht mehr die Stelle, wo das irgendwo drin steht,

dass da drin gesucht werden soll, also

Dispass, ja, aber es gibt auch noch irgendwie

andere Stellen, glaube ich. Es gibt auch noch Module,

die nicht da drin sind, zum Beispiel die

Standardbibliotheksmodule

sind, also es gibt welche, die sind irgendwie in

das Python-Binary reinkompiliert und dann gibt es

auch noch welche, die sind irgendwie

woanders hingemarschelt, aber die liegen da auch irgendwo rum.

Also die Python-Module,

die nicht zählen.

Das stimmt, das kann man, aber es gibt auch noch

Dinge, Module, die sind halt einfach nur

in der Shared Library

und nicht irgendwie Python.

Aber da kommen wir gleich noch so,

wo der Pycache und so weiter noch was, aber egal.

Genau.

Aber man kann halt auch,

es gibt auch Verzeichnisse und denen wird

auch gesucht, wenn da kein NPY ist,

das ist allerdings dann irgendwie

weiter hinten.

Und alle, die den gleichen Namen haben,

wenn da jetzt Sachen drin liegen, dann wird das

zum gleichen Paket

gehörig irgendwie aufgefasst

und das ist dann so ein Namespace-Package.

So ein Namespace-Mengeling.

Und dann kannst du halt auch...

Also wir halten fest, einfach immer eine Init-Pi.

Ja, dann...

Aber so kannst du

halt auch Dinge in einem Paket haben, die in unterschiedlichen

Verzeichnissen liegen, was halt manchmal auch ganz praktisch ist.

Klar.

Ja, okay.

Okay.

Was ist dann, das haben wir gesagt,

Package, es gibt auch ein dann dann Package.

Was steht denn da?

Ist das Current Package?

Genau.

Das ist das aktuelle Paket.

Das ist ein Top-Level-Modul oder sowas, ja?

Ja, oh Gott, ich weiß auch nicht.

Ich glaube, wenn es None ist, dann ist es ein Skript.

Also vielleicht noch mal zu distinguieren,

ist das ein Modul, ein Paket oder so?

Wenn Package None ist, dann ist das nur ein Skript.

Und wenn er sucht, dann auch, wer so ein Package findet.

Und wenn er eins findet, dann ist das Top-Level-Modul,

von dem man dann importieren kann oder so.

Und wenn es das nicht gibt, dann gibt es halt auch

Fehler. Attempted Relative Import

Beyond Top Level Package.

Ja, das ist

so eine Sache, die gibt es.

Passiert mir auch

regelmäßig. Echt, das passiert mir nie, das ist

voll seltsam. Doch, passiert mir auch. Es gibt so Sachen, die

machen Menschen offensichtlich

unterschiedlich und das ist so eine Sache, die mache ich offenbar nicht.

Also nicht, weil ich besser bin oder

weil ich irgendwie das toller kann oder so, sondern

weil es einfach was ist, was ich nicht benutze.

Ja gut, aber wenn du relative Importe benutzt, wie du gesagt hast.

Die liebe ich. Relative Importe sind voll gut.

Davon vertippt man sich ja mal.

Also relative Importe, jetzt müssen wir über relative Importe sprechen.

In Python 3

und ich glaube in 2.7 wurde das dann

irgendwann geportet, gibt es die Möglichkeit zu sagen

from .import irgendwas.

Also from .import m.

Oder vom .dot.

Oder auch from .m

import irgendwas.

Und dieser Punkt heißt halt eben immer

aktuelles Verzeichnis.

also aktueller

Pfad.

Das heißt, wenn es in dieser

Installation, die ich habe, zwei Module gibt, die

M heißen, dann kann ich durch

diesen relativen Import genauer sagen,

welches ich meine.

Ach, okay, doch, nee, das war der Unterschied zwischen Modulen

und Packages.

Module haben einen Pfad dran.

Ich glaube tatsächlich, das ist der entscheidende Unterschied.

Ich glaube schon, ja.

Genau, die Top-Level-Package

ist halt irgendwie doch die Sache.

Also wenn man ein Paket finden kann,

also ein Top-Level finden kann mit diesem Dot-Dot,

dann geht das halt. Aber wenn das None ist,

weil man quasi auf der höchsten Ebene ist, dann gibt es halt Fehler zurück.

Und das ist ja genau der Grund, warum...

Das kann natürlich sein, dass ich das einfach nie...

Also für mich ist einfach Punkt, ja.

Wenn ich sage from Punkt importen, dann weiß ich,

das muss im aktuellen Verzeichnis liegen.

Wenn ich sage from Punkt Punkt, dann weiß ich,

das muss im Verzeichnis drüber liegen.

Und für mich ist das einfach eine Möglichkeit,

quasi in meinem Projekt zu navigieren.

Also ich sag mal so, das geht aber nur dann,

wenn der Interpreter richtig aufgelöst ist,

weil wenn du tief drin bist und dann das Skript

beispielsweise manuell ausführt,

relativ tief drin, dann wird der ja diesen Fehler schmeißen.

Wenn du diese Datei direkt

aufrufst. Das kann man übrigens verhindern,

indem man einfach sagt, Python-m

und dann dieses Modul dann innerhalb

von dem Pfad aufrufen.

Die meisten meiner Projekte sind ja bei einem Django-Umfeld.

Und da bin ich nie in der Verlegenheit,

diese Sachen direkt aufzurufen, sondern die werden dann

entweder über einen Run-Server

aufgerufen oder über einen Test oder

über einen Command.

Auch da ist der Pfad, musst du ja

richtig definieren. Ja, aber der Pfad ist

immer festgemacht an der Managed-Py.

Genau. Das heißt, das weiß ich.

Ich weiß, wo der Pfad...

Ja, aber das ist ja auch Python-USM-Package.module oder so.

Genau. Und deshalb ist das vielleicht

was, was einfach in meiner täglichen

Arbeit nicht so auftritt, dass ich da

mich quasi vernavigiere,

weil meine Projekte eben immer

eine feste Wurzel

haben und darunter kann ich

mich bewegen, wie ich möchte.

Ja, mir passiert das halt vor allen Dingen dann,

also einmal, in Paketen

habe ich oft gerne Tests und in anderen

Verzeichnis. Also da gibt es halt Test nicht innerhalb von dem Projekt selber,

sondern liegen halt in einem Test Directory. Wenn da irgendwas nicht richtig konfiguriert ist, dann passiert das halt

schon mal. Und was mir halt auch ab und zu passiert ist,

in Jupyter Notebooks, weil die liegen halt auch wieder in einem anderen Verzeichnis.

Und die sind halt auch irgendwo. Genau. Und deswegen sehe ich das halt

häufiger mal. Bei diesem Import auch ganz interessant. Ich glaube, das kommt dann wirklich darauf an, wenn der Name

des Moduls Punkte enthält oder halt nicht.

weil wenn er Punkte hat, dann

Achso, wenn der Name des Moduls, also wenn das

Modul quasi m.x.y

Genau, dann ist es halt

ein paar Reihenverkehrs

und wenn es halt

wenn es halt keinen Punkt mehr hat

dann muss es eigentlich schon

Top-Level sein, weil dann kannst du nicht

Aber man kann ja jetzt auch so Dinge tun wie

man sagt

from m import

x oder so

und was mit Wings dann. Habt ihr schon mal Skriptnamen mit

Punkten verwendet? Also mit mehreren Punkten drin?

Nee, das hab ich gerade jetzt überlegt, ob ich

eine Datei mit

Punkten drin hätte, ohne also Punkt

Py. Ich glaube, dass das

zu Problemen führt, oder? Ich glaube auch, dass das zu Problemen

führt und das würde ich auch vermeiden einfach.

Ja, interessant.

Stimmt, das hab ich auch noch nicht.

Das müssen wir, das wird dann die nächste

Episode. Was passiert eigentlich, wenn wir Punkt 1

geben? Ja, genau.

Achso, genau, die Form

import m ist ja

noch vergleichsweise offensichtlich. Aber jetzt hat der Jochen eben gesagt,

was ist denn, wenn ich sage, from m import x?

Genau.

Und was dann halt für mich passiert ist,

er importiert erst m

und guckt dann

in m nach, ob es da etwas gibt, was x heißt

und gibt mir das als Import.

Aber das stimmt nicht ganz.

Weil es kann nämlich auch,

man kann auch from m import x machen,

wenn es in m gar kein x gibt.

Weil eben,

wie angekündigt,

wenn m eine

Verzeichnis ist, was eine InitPy enthält.

Dann kriege ich aus dem

Import M alles das raus, was in der InitPy

drin ist. Aber from M

Import X kann dann die Datei X.py sein.

Also M-X.py

und die kann ich mit,

also an die komme ich dran,

aber die ist nicht

in M selbst enthalten. Also wenn ich nur Import M mache,

gibt es nicht M.x.

Kann so sein. Deshalb

ist es dann doch

immer noch ein kleines bisschen

anders. Also man muss eigentlich immer auf die Datei

zeigen, die wir haben.

Ja, genau, das hat mich auch überrascht.

Das wusste ich nicht, wenn man sagt,

import x, ich weiß nicht, was ich vorher gedacht habe,

aber ich dachte, das holt das x da raus

und dann hat man das halt im eigenen Namespace.

Aber eben, es macht halt eher sowas wie import m,

dann sagt es x gleich m.x

und dann sagt es del m.

Und das ist halt eher so das, was tatsächlich passiert.

Und das ist auch schon so, ui, ui, okay.

Also wenn es nicht geht, macht er doch was anderes.

Dann holt er sich doch noch die Detail.

Ja, ja, ja.

Also

es ist natürlich alles übrigens noch gecached.

Man kann so oft import m machen, wie man möchte.

Es wird nur einmal gelesen, die Datei.

Und wo wird das dann reingeschrieben?

In das Dictionary der offenen

Module?

In das Dictionary der geladenen Module.

Das heißt irgendwie sys.modules.

Ja, weiß ich auch nicht.

Keine Ahnung.

Das heißt sys.modules.

Dominik wei es Das ist auch so eine Geschichte das kann man auch sch verwenden Manchmal braucht man ja also Singleton ein ehrlich gesagt

Es hat einen total coolen Namen,

deswegen wollen es die Leute immer verwenden.

Manchmal braucht man das.

Manchmal braucht man es tatsächlich,

meistens eher nicht.

Aber Module sind immer Singletons.

Ganz genau. Und das ist tatsächlich die eleganteste Art,

die ich kenne, wie man das macht.

Und es ist auch manchmal total nervig.

Ja, aber

ich habe da vorher schon

also meistens habe ich dann Borg-Pattern verwendet

oder halt irgendwas in der Richtung

oder manchmal halt auch, wenn ich nicht Borg wollte

sondern direkt Singleton, dann wurde es aber schon hakelig

dann muss man schon

so Meta-Klassen oder sonst irgendwie sowas

so Dinge, wo man sich hinterher schon ein bisschen schmutzig

fühlt, irgendwie machen und

bis ich dann irgendwann mal, weiß ich gar nicht, wo ich das gesehen habe

den Trick, so dass jemand meinte, ja ja, Module sind doch sowieso

Singleton, es sind doch einfach globale Variablen

in einem Modul

Ja, stimmt ja

Stimmt.

Das muss man ja nochmal genau erklären, warum das ein Singleton ist.

Aber Jochen, wenn du dann das Pattern richtig ausführen

musst, musst du dann noch in dem Modul noch ein

Get irgendwas

machen.

Ja, ja.

Falls jemand versucht,

drumherum zu kommen.

Ja, genau. Eigentlich ja.

Jetzt der Dominik

möchte es gerne erklärt haben.

Also ein Singleton macht irgendwie,

dass er guckt, ob es schon ein Objekt gibt,

das dieses Typen ist und gibt das

zurück, wenn es schon gibt, und schert einfach das eine,

was es nur geben darf. Ja, Singleton heißt ja erstmal

nur, es gibt während der Ausführung des

Programms nur eins davon.

Egal, was davon ist.

Und Borg ist, dass es gibt ganz viele davon, aber die sind

alle dieselben Eigenschaften.

Ja, da wird der State

geshared, aber es ist nicht die gleiche Instanz

tatsächlich. Es können unterschiedliche Instanzen

sein, aber der State ist immer der gleiche. Genau, das heißt,

die Eigenschaften sind alle dieselben über alle Instanzen hinweg.

Ja, genau.

Und Singleton kriegt man eben durch

Modul einfach hin. Also ich mache eine Datei

singleton.py

und da schreibe ich rein x gleich 2.

Dann mache ich import singleton

und dann sage ich singleton.x

und das ist jetzt diese

Instanz, dieses .x

gibt es nur genau einmal, weil der

Python Interpreter eben beim Import

jede Datei

nur einmal importiert, um es mal so zu sagen.

Wenn eine Datei einmal importiert wurde,

dann liegt die im Cache und dann

wenn du dann import singleton sagst, kriegst du wieder

die aus dem Cache.

mit allen ihren Eigenschaften.

Das heißt,

du kriegst es mit dem...

Du kannst es nicht ganz

einfach machen, dass du diese Datei nochmal

importierst, weil Python halt sagt,

ja, die kenne ich ja schon. Brauche ich nicht nochmal

importieren.

Weil dieser Import,

was ist das? Ein Modultyp dann,

wenn du ein Modul hast? Genau, das heißt Modul.

Und dieser Modultyp ist einfach

eine Detailkette, keine Ahnung, von dem...

Ja, das Ausgeführte.

Das ist eigentlich der ausgeführte Code, der da drin ist.

so einer Closure, die außen rum...

Aber das wird dann doch gecastet,

was dann Eval wäre, oder das habe ich dann nicht genau...

Ja, im Endeffekt macht es ein Eval,

aber halt ein

sehr gut verstecktes.

Ja gut, ich meine,

Import heißt, führ mal bitte den Code

in der Datei XYZ aus, also

musst du ihn irgendwie ausführen. Irgendwo muss da ein Eval

drin sein.

Aber es ist eben hinter so vielen Schichten

versteckt, dass du es nicht siehst. Also was der macht, ist,

er lädt diese Datei... Immer wieder und immer wieder.

Das heißt, wenn ich auch von mehreren...

letzte einmal. Aber wenn ich an mehreren Stellen das habe,

was ist denn dann passiert?

Beim ersten Import Singleton wird diese

Datei geladen und ausgeführt und

das Ergebnis dieser Ausführung wird als

Module Singleton

abgelegt in diesem SysModulesCache.

Und vielleicht wird dann da PyCache

rausgebracht, PyC-Files oder so?

Ja, nee, das ist nur eine interne

Repräsentation. Das ist halt eben ein

internes, das ist eine Klasse, die heißt

Module und die hat Eigenschaften.

Ja.

Und wenn du dann nochmal Import Singleton

machst, zum Beispiel in einer Datei oder

zu einem späteren Zeitpunkt oder in einer Schleife, wo du es

tausendmal machst, dann wird

nicht nochmal diese Datei singleton.py

geladen, sondern dann guckt er eben in seinen

Sysmodules Cache und sagt, ah ja, den Namen singleton kenne ich schon.

Genau, also beim ersten Import

lädt er das tatsächlich in den Pycify

rein, also das heißt, er macht aus Bytecode draus,

er komponiert das quasi und

er liest das quasi einmal aus,

und man kippt das aus,

macht dann Bytecode draus und dann schreibt er das

in Pycache rein und von da versucht er dann

erstmal zu laden aus Pyc.

Genau.

und dann ist dieser Code nicht mehr da.

Es ist nur noch das Ergebnis da.

Das Ergebnis der Ausführung dieser Datei

ist dann das, was in das Modul reicht.

Und was wird dann in die PyC-File reingeschrieben?

Die PyC-Files sind so eine

zwischendurch Optimierung, weil

die

enthalten so einen vorkompilierten Bytecode

und der ist schneller zu laden als eine

.py-Datei. Und das ist ein

Marschalt-Objekt. Also wir hatten die ganz am Anfang

einmal kurz Marschalt gesagt. Was ist das überhaupt?

Einmal kurz nochmal den kleinen Exkurs.

Jochen, erklär du doch mal.

Ach ja, damals. Genau, im Grunde Marschaling ist eigentlich ein anderes Wort oder ist eines der Worte, die man benutzt, wenn man jetzt zum Beispiel Code oder irgendwie eine Datenstruktur serialisieren möchte in eine Liste von Buchstaben oder in einen String oder in eine Byte-Datenstruktur, die man dann halt irgendwie auf einer Platte speichern kann oder mit sich rumtragen.

und genau, und da gab es zwei Module, die ersten waren halt Marshall,

das heißt auch so, das gibt es immer noch in der Standardbibliothek,

und Shelf, Shelf war schon damals nicht so richtig populär,

also Marshall kann man immer noch verwenden, kann halt nur relativ wenige Datentypen

und in neueren Python-Versionen verwendet man da eigentlich immer Pickle für,

aber das ist halt im Grunde das, was es macht, wenn man sagt,

vom Pickle, oder wenn man sagt cpickle.dump, dump-s oder so,

dann wird das halt in String oder dump in einen Teil geschrieben

und dann hat man halt eine in einem String

serialisierte Form von zum Beispiel irgendwie

Code. Also mittlerweile nutzt man glaube ich sogar

Dill oder sowas, ne?

Dill as Pickle oder so,

als neue Version. Ja. Als Third-Party-Package

irgendwie, ja. Schön, schön.

Können wir auch machen. Okay, aber ein Marschall-Objekt,

falls ihr das irgendwo findet, ist quasi eine serialisierte

Form von

dem, wie es heißt, Code, der da

gelaufen ist, ja. Genau.

Okay, jetzt haben wir aber, okay, jetzt haben wir es irgendwo geladen,

haben wir es gefunden. Was importiert ihr dann?

Was ruft ihr dann auf? Ja, das

Ergebnis dieser Ausführung.

Also import.dot, dann dann import.

Dann dann.

In diese Funktion kommen

dann halt die Argumente rein, die

Ja, das kann ja alles möglich sein.

Da kannst du auch beliebige Objekte

in der Datei reinschreiben.

Kannst auch ein Modul machen, was einfach nur einen String enthält,

wo irgendwelche Binärdaten drin sind.

Macht man ja manchmal,

weil man Testdaten braucht.

Das Modul hast, wo einfach

so ein paar Strings drin sind. Und wenn die

eben ausgeführt werden, dann werden die halt so einer

String-Objekt in Python

mit einem Namen und genau diese

Sachen, also im Endeffekt ist das halt so

ein Dictionary, was da drin ist, so ein Unterstrich, Unterstrich,

Dikt, Unterstrich, Unterstrich.

Das hat natürlich noch mehr so Attribute, ja.

Der Path ist da drin

und der ursprüngliche

Importname und der Docstring

wird rausgelesen und so weiter. Also diese ganzen

Sachen, die halt so passieren, wenn Python was

ausführt,

die passieren da auch. Alles das, was Python langsam

macht. Alles das, was Python awesome

macht.

Genau, und das Ergebnis dieser Ausführung ist halt dann das, was das Modul ist.

Das zusammengefasste Modul. Da gibt es Modul.doc und Modul.tikt und Modul.

was weiß ich noch alles, .name und .path und .package

Genau, also alle diese Sachen, die halt dazu gehören. Aber das ist dann schon ein Python-Objekt.

Also es ist keine Datei mehr, sondern es ist dann ein fertiges Python-Objekt.

Und auch diese Klassen, die müssen ja erzeugt werden

und wenn es so Meta-Klassen hat, dann müssen die ausgeführt werden. Also alles das, was da

wenn man die Datei in den Interpreter eingibt

und dann alles was da rauskommt

eben zusammenfasst

in eine Sache gepackt

also es ist eigentlich von der Organisationsebene her

finde ich sehr sauber

weil alles was in der Datei drin ist

ist dann eben als Python Objekt verfügbar

und das ist auch für mich so ein bisschen

der Grund warum man das braucht

dass ich halt einfach bestimmte Python Objekte

oder bestimmte Dinge in andere Dateien

reinschreiben möchte

und diese Dateien sollen in anderen Verzeichnissen liegen,

damit ich nicht die Übersicht verliere.

Und ja.

So, das ist Import.

Und jetzt

gibt es noch Importlib.

Ja, das wird ja

aufgerufen sogar, also Import wird ja Import,

auch wenn man es nicht überschrieben hat.

Import ist eigentlich syntaktisch, genau, das kommt ja

auch noch dazu, das ist ja in dem Artikel

glaube ich nicht drin, aber in der Diskussion war es dann drin,

man kann das auch überschreiben, man kann auch

selber eingreifen in den Importprozess.

also Dinge, die man

auf der Liste der Dinge, die man unbedingt tun sollte

ist das ganz, ganz

weit unten

Es gibt

Importlib und in Python 3 irgendwas

hat auch

dieser Importprozess ist quasi

zu einer Python-Funktionalität geworden

den man programmatisch

aufrufen kann, was sehr nützlich ist

und

diese Statement

Import M ist quasi nur noch

ein syntaktischer Zucker für

importlib.

.import

Ja, irgendwie sowas.

Das

coole daran ist, dass man

eben jetzt in diesen Prozess eingreifen kann.

Und das ist insbesondere dann für zwei Sachen nützlich.

Die erste Sache, für die es super nützlich ist,

da muss ich jetzt leider auf meine eigenen

Dinge verweisen, da werde ich

in Kürze ein Video dazu hochladen.

kommt dann natürlich in die Show.

Wenn man etwas

neu laden möchte,

weil

wir haben ja eben besprochen, wenn ich Import M

mache, dann wird es einmal geladen

und dann nie wieder.

Man ist ja jetzt oft als Softwareentwickler in so einer Situation,

dass man Dateien dann verändert und die

eigentlich sofort

haben möchte, ohne dass man das Programm

neu startet. Und um das hinzukriegen,

habe ich mir halt so ein bisschen

einen Glue-Code geschrieben, der Dateien

überwacht und wenn die sich ändern, dann wird da halt

Reimport durchgeführt.

Und das ist möglich durch die Funktion

aus Importlib. Da kann ich sagen,

importiere diese spezifische Datei,

auch wenn

die schon mal importiert war,

und dann

wird die importiert. Egal, ob die schon im

Cache liegt oder nicht. Ja, cool. Ja, ich meine,

der Entwicklungshelfer von Junkmo,

der kann sowas ja auch. Ja, aber der macht ja

einen Neustart. Der macht tatsächlich einen Neustart, naja.

Der hat so einen Watcher-Prozess und dann

schießt er einfach den Prozess ab und startet einmal neu.

Ach so, ich weiß gar nicht, wie das

gut, das ist ja, oh mein Gott, das ist ja schrecklich.

Ja, aber es hat auch Vorteile,

weil dann halt alles

auf Null zurück ist.

Wie ist das denn bei

Jupyter, ist das ja auch so, da kann ich ja auch beim

Import sagen, ob ich das jetzt möchte,

dass ich das nochmal importieren will,

wenn es sich ändert. Ja, dann mach doch ein Reimport.

Da gibt es eben diese Jupyter Magic,

die du sagen kannst, und der benutzt

tatsächlich Import-Lib und macht Reimport.

Aha, okay.

Neustarten wäre auch blöd.

an der Stelle.

Geht ja auch an der Stelle einfach gar nicht.

Zum einen, weil der Prozess ja da

läuft und zum anderen, weil

der die anderen Zellen nicht kaputt machen will.

Das heißt ja, die Zellen immer noch.

Ich hatte übrigens tatsächlich jetzt

letzte,

vorletzte, nee, letzte oder vorletzte, nee, glaube letzte

Woche, und ich erinnere mich schon nicht mehr dran,

den Fall, wo ich tatsächlich Importlib gebraucht

habe und habe halt die Importfunktion

überschrieben.

Was hast du damit gemacht?

für einen, ich habe einen

Pull-Request bei Wagtail Media

eingereicht, weil

es nicht mit Wagtail 2.13 kompatibel war.

Und da gibt es Tests

und das Problem ist jetzt,

man möchte die Tests

ja, also da ist

dann, okay, ich fange einfach mal von der Seite

an, es gibt im Code so Dinge wie

probier das mal zu importieren,

wenn es schief geht, mach was anderes, weil

zum Beispiel diese Telepath

Bibliothek gibt es erst ab Worktel

2013.

Und da sagt man halt, probiere es zu importieren.

Ja, auch für lokale, ich benutze es ganz häufig für lokale

Settings, ja. Irgendwo eine local settings.py

und dann macht man halt

try import local settings.py

und accept pass.

Ja. Genau, genau.

Und jetzt müsste man das aber testen.

Jetzt möchte man testen, dass wenn

und es gibt da noch kompliziertere,

wie gesagt, das habe ich jetzt wieder vergessen, blöderweise, ein bisschen kompliziertere

Logik, die davon abhängt, ob man es jetzt geschafft

hat, das zu importieren oder nicht.

und jetzt, wie willst du das testen, ob jetzt wirklich der richtige Code ausgeführt wird, also der Code, der zum Beispiel dann nur so ein Dummy-Objekt anlegt,

wie willst du testen, ob das funktioniert hat, wenn du nicht dann noch eine andere Paketversion installieren willst, was du im Test auch nicht gut machen kannst?

Ja, und dann habe ich da einfach quasi Import-Funktionen überschrieben und dann in der Import-Funktion gucke ich halt so, wird gerade versucht, das da zu importieren?

Ja, wirklich? Gut. Race-Exception, ja, und dann Race-Import-Error.

und dann kann man halt testen, okay, und ist jetzt wirklich das Sammely-Objekt, ja oder nein?

Und dann hat man einen Test dafür.

Ja, aber fand ich spannend.

Das ist auch ganz schön tief eingegriffen.

Ach, der Jochen auch aufgenommen?

Ja, genau.

Du musst jetzt aber suchen, in welcher Folge das war.

Kannst du uns da einen Link geben, Jochen?

Kann ich auch mal in die Schauenden folgen.

Das ist ja cool.

Ja.

Ja, was kann denn noch alles dann passieren?

Genau, das ist jetzt sozusagen, der Jochen hat jetzt hier schon die Brücke zu dem zweiten Anwendungsfall geschlagen,

was dann eben hier aus diesem Artikel in der Diskussion

rauskam, man kann auch

im Importsystem was anderes

machen

und der schöne Vorschlag, der da kam

beziehungsweise das schöne Beispiel, was da in

dieser Diskussion kam, ist

dass man ja prinzipiell auch andere Sprachen

integrieren könnte. Einfach Importsystem auf einen ansetzen

Das kann man auch machen, dann ist man in

seiner eigenen Welt

aber quasi das Gegenteil

davon ist, wenn kein Python-Modul

gefunden wird, dann kann man ja mal schauen, ob man irgendwas anderes

kompilieren kann, was diesen Namen hat

und wenn das

kompilierbar ist und kompiliert, dann einfach das

importieren. Und es hat wohl jemand

geschrieben, dass jemand sich eben so Lisp-Dateien

rein importieren kann, die

live kompiliert werden, wenn man

sie importiert.

Reichlich abgefahren, würde ich sagen

und ich empfehle auch niemandem, diesen

Weg zu gehen, aber es ist

schön, dass es jemanden gibt, der das

gemacht hat und das möglich ist.

Ich wüsste

jetzt tatsächlich keinen richtig sinnvollen

Anwendungszweck davon, aber

Ja.

Irgendwann wird es

einen Anwendungsfall geben.

Ich habe gerade überlegt,

wenn man das jetzt mit TypeScript macht,

man möchte auf dem Backend

und vorne den gleichen Code.

Ja, und dann wird es noch

mit dem JavaScript to Python

Compiler noch Python gemacht.

Dann hat man noch einen Server,

was WebAssembly kann.

Man kann Python schreiben für Frontend.

Und schon

eigenes, die eigene, deine Dateien bestehen quasi nur noch aus Import Statements. Alles mit Import Statements gemacht. Ja, das ist so wie der Präprozessor, der ist auch Turing vollständig.

Ja, tja.

Da hat jemand super wieder sein...

Vorhin haben wir noch drüber gesprochen, ob wir unser Telefon ausschalten wollen.

Flugmodus gestellt, aber nicht

mein Rechner.

Auf meinem Telefon hat es auch nicht geklingelt, sondern

mein Rechner kann halt auch dummerweise klingeln.

Was kann denn noch alles schief gehen bei den

Importen? Ja, eigentlich kann beim Importen alles

schief gehen, oder? Das ist ja...

Ja. Da steht irgendwas

komisches drin, also keine Binärcodes oder irgendein andere

Zeichen, das er nicht lesen kann oder sowas.

Ja, es kann auch...

Ich glaube, das Schwierigste an diesem Importsystem

ist, dass es halt manchmal überraschend ist.

Dass es einem Sachen versucht zu importieren,

die man nicht gemeint hat.

weil die Reihenfolge im Path falsch ist

oder weil da Module liegen, die man noch nicht kennt

oder weil man versehentlich

einen Namen verwendet hat, den es schon gibt.

Also wenn man so eine Kette durchgeht,

also man möchte jetzt A importieren und A

möchte aber jetzt C, D, E, F, G und

Genau, sowas kann natürlich auch passieren, dann hast du zirkuläre

Imports, das ist auch schlecht.

Ja, aber das wäre ja von A von B und B von C

und C von A. Ja genau,

und das hat man ja manchmal.

Aber das war ein anderes Problem, als das ich gerade meinte.

Das ist also ganz, ganz, ganz viel Zeug.

importiert. Also du könntest ja quasi eine Sache importieren, der importiert

alles andere, die ganze Standard-Python.

Im Prinzip machst du das ja so in deinem Skript.

Das ist halt so relativ getarnt,

was da passiert. Man macht relativ viel

Magie schon.

Die komplizierte

Frage wäre, ob das das dann doch langsam macht,

wenn man sowas raussucht und sagt,

beim ersten Mal schon. Das heißt, da kann der Starten

relativ lange dauern und beim zweiten Mal

vielleicht nicht. Aber es gab irgendwie

so ein Problem, dass irgendwer hatte, der das

mal ausprobiert hat wegen den Imports.

immer wieder. Ja, ja, ja. Also das Problem

gibt es halt, wenn du halt irgendwie so auf die Richtung

weiß ich nicht, Millionenzeilen

Python oder so zugehst, dass eben dann, wenn das

zum Beispiel im Entwicklungsserver, wenn der neu startet,

wenn du änderst irgendwas, dann startet der neu

und dann dauert das halt eine Minute.

Das ist halt schlecht. Das ist halt immer so richtig

flüssig beim Entwickeln. Es hieß ja

irgendwie so, ne, wir haben das Google, aber ich glaube,

das war bei Instagram das Problem oder so.

Ja, bei Instagram gibt es auch bei

Eventbrite gibt es das, glaube ich, auch.

Ja, die sind nicht so groß wie Google.

Ja, aber die haben, glaube ich, auch irgendwie

oder

verwechsel ich das gerade?

Ich meine, es ist Eventbrite, aber auch ungefähr eine Million

Zahlencode und Instagram halt auch

vielleicht noch mehr, weiß ich.

Ja, okay. Aber das ist ja dann so

ein...

Das Problem ist ja eigentlich, dass halt die Sachen

erst so in Anführungszeichen kompiliert werden,

wenn ich Import sage.

Und deshalb haben andere Sprachen das nicht, weil die

machen das halt einmal vorher.

Aber so eine richtig gute Lösung,

also ich meine, es gibt PyO-Dateien

und PyC-Dateien,

die sind ja wohl schneller

ja

oder könnte man

sowas auch marscheln

könnte man Imports durchführen

und das dann, ja im Prinzip schon oder

wahrscheinlich schon ja

einfach mal alles gepickelt

ja

ach deswegen auch weil der Pickel ist die Haube von dem Marschall

jetzt verstehe ich das auch

ich dachte Pickel ist so ein Einmachglas

Marschalls haben doch so eine Pickelhaube auf

ja, also dann passt das auf jeden Fall

zusammen

Das ist doch zumindest schon irgendwie

Sorry, weigert es

Das Englische, wo Pickels heißt, eingemacht ist

Ja, ja

Ich glaube, das ist die

Okay, aber zirkuläre Importe wollte ich nochmal

Ja, zirkuläre Importe sind auch eine schöne Sache

Also man kann ja sowas machen wie in Python

Form A, Import B und dann

B machen, Form B, Import irgendwas

oder Import A, Import B, Import D und so

und das funktioniert einfach, aber erst wenn man es dann ausführt

dann nicht mehr, weil er dann darauf zugreift

und dann sagt, das kennt er noch nicht

Genau, beziehungsweise ist schon geladen

oder ist schon am Laden.

Also wenn ich

zirkuläre Verweise

habe, vom A Import B und in B

sage ich vom, wenn ich

Modul A und B habe und in A

sage ich Import B und in B sage ich Import A,

dann kann ich die beide nicht importieren, weil zu dem

Zeitpunkt müsste ich sie beide gleichzeitig

importieren und das geht nicht.

Und da kann ich natürlich beliebig

viele dazwischen schieben. Ich kann A, B,

C, D, E, S. Solange dieser

Kreis sich irgendwann schließt,

ist schlecht.

Also es fällt ja direkt auf. Ich glaube, wenn man drei hat,

dann fällt es glaube ich nicht immer direkt auf.

Wenn man vier oder fünf hat, dann fällt es erst recht.

Das siehst du dann beim

Importieren. Und wie löst man das denn, wenn man

so ein Problem hat?

Laufzeit-Imports.

Also lazy quasi.

Das ist doch das, was man in so

Salary-Tasks immer machen muss.

Weil diese Tasks können von irgendwo her

gestartet werden und die sollen dann irgendwas machen.

Und die müssen

ja auch irgendwie diese Modelle importieren, aber das Modell

selber m Also das ist so mein klassischer anwendungsweise Ich m dem Modell sagen ich muss hier Werte nachberechnen ich muss hier ein PDF erzeugen und das dauert lange und deshalb mache ich

das in dem Task. Aber dieser Task soll ja dann wieder

dieses ursprüngliche Modell speichern.

Das heißt, ich kann in der Tasks-Datei

nicht das Modell importieren,

weil das Modell hat schon den Task importiert.

Und deshalb ist das so ein

Pattern, wenn man Celery-Tasks schreibt,

dass diese Tasks

zur Laufzeit alles importieren. Also

in der Datei, in der Funktion

dev compute pdf.

Da habe ich erst mal ein paar

Importzeilen drin. Import from models

import irgendwas.

Import pdf generator.

Und noch alles, was man da halt so importiert

braucht. Und dann werden diese

Imports erst ausgeführt, wenn die

Funktion gestartet wird. Also von mir, von meinem

geistigen Auge, die ich mir gerade so ein paar Tickets ziehe.

Die To-Do-Listen müssen ja an.

Genau.

Das bedeutet halt, dass dieser Import nicht

ausgeführt wird, wenn die Datei geladen wird.

Was eben der

Fall wäre, wenn es oben in der Datei drinstehende,

sondern dieser Import wird erst ausgeführt,

wenn die Funktion, die da drin ist, gestartet wird.

Weil quasi nur der

Funktionsname geladen wird und das, was

passieren soll quasi. Genau, richtig.

Und wenn ich diese Funktion dann ausführe,

dann wird dieses Import Statement ausgeführt.

Und dann sind die anderen Sachen schon da

und dann hat man quasi den Laser Import, dann kann man

das dann wieder machen, weil die sind ja schon...

Das ist dann schon fertig, importiere diese Models, die sind schon im Cache,

dann kann ich einfach in den Cache zeigen und sagen, hier gibt man das.

Bin also

sozusagen aus diesem Prozess raus.

und das ist auch sowas, was eben

anders ist als in anderen Sprachen.

Import ist ein Statement, was einen Effekt hat.

In C, wenn ich

in C sage, import header.h,

dann hat es keinen Effekt,

das ist kein Code, der da erzeugt wird.

Punkt H ist immer Header,

noch mal für alle Leute kein C.

Punkt H ist immer Header, das sind so die

Definitionen, die Deklarationen,

nicht die Definitionen, die Deklarationen, was es da gibt

und die Punkt C Datei enthält

dann die Definitionen normalerweise.

Also Header.h ist natürlich die Definition der Header.

Die Definition,

da muss ich dann eine

Datei dazugeben, die heißt

Header.c

War nur ein Beispiel.

Aber

dieses Import-Statement in einem c,

das wird vom Compiler ausgeführt, das wird nicht

zur Laufzeit ausgeführt.

Und in Python ist das anders.

Der Compiler, der macht das,

der schneidet die einfach zusammen, alle zu einer großen Datei

und dann liest der einfach von oben nach unten.

und dann gibt es noch den Linker, der dann dafür

sorgt, dass diese Verweise alle an der korrekten Stelle

in die korrekte Stelle zeigen. Das ist so ein

mehrstufiger Prozess und es ist halt alles

bevor das Programm gestartet wird.

Und in Python ist immer alles

nachdem das Programm gestartet wird.

Und das ist halt hier genau das Problem. Wenn ich

Import B sage und

versuche aber schon was zu importieren

oder versuche schon B zu importieren,

dann geht es halt nicht.

Weil das dann eben so einen Kreis

bildet, der nicht aufgelöst werden kann.

Wenn ich das aber erst später im Programm sage,

wenn ich irgendwelche Funktionen geladen habe,

die dann später nochmal

diese Module brauchen.

Ist egal, wo die herkommen.

Wenn die schon im Cache sind, einwandfrei.

Okay, aber das widerspricht ja so ein bisschen dieser

Philosophie, dass Importe immer ganz oben stehen.

Ja, genau. Deshalb ist das hier so der

Nachteil da dran.

Ja, ich fühle mich da auch immer so ein bisschen schmutzig, aber

ja, ich mache das auch so. Aber es ist halt das Pattern

und das ist der beste Weg außenrum.

Es gibt noch eine andere Möglichkeit,

die ich auch

niemandem empfehlen möchte. Es ist ein sehr schöner Hack,

den ich mal gehört habe.

Wenn ich jetzt zum Beispiel nur einen Task importieren möchte,

dann sage ich from tasks import

greatpdf.

Und der Importprozess führt

tatsächlich nur so lange diesen Import

aus, bis dieses Objekt vorhanden ist.

Alles was unterhalb dieses Objektes ist,

wird

nicht ausgeführt.

Das heißt, wenn ich meine Importstatements

ans Ende einer Datei mache,

dann kann ich zirkuläre Importe

machen,

in bestimmten Situationen, dann geht

das.

Aber

das, wie gesagt, ist keine

Empfehlung. Es ist nur

Imports ans Ende der Datei schreiben ist

schon generell schlecht, weil man sie dann nicht mehr sieht

und es ist auch dann schlecht, wenn man dann

zirkuläre Importe... Das kann man dann wahrscheinlich auch noch

ein bisschen verschachteln oder so. Also alle Leute, die

ein größeres Interesse

an Job Security haben, jetzt mal

aufpassen mit Schreiben.

Das kriegt man hinterher nie wieder aus

und wenn man dann noch

Homoglyphen nimmt und die Dateien

alle gleich ausschauen, dann

hat man ganz gewonnen.

Ja, das ist ein Hack, der

die Interna missbraucht, würde ich nicht empfehlen,

aber es ist schön, dass es das gibt.

Ja,

ist auch manchmal interessant

zu wissen, warum irgendwas funktioniert, wo man

denkt, das kann gar nicht funktionieren, aber es funktioniert

dann doch.

Ja, ja.

Nicht so selten, wie es funktioniert, was nicht, was eigentlich funktionieren sollte, aber trotzdem auch.

Leider.

Ja.

Ja, Imports haben wir, oder?

Ja.

Erklärt, oder fällt euch noch was ein?

Bin mir sicher, dass da noch ganz viele Fragen kommen.

Vor allem, wie funktionieren Imports in anderen Sprachen?

Ja, anders.

Ja, das nicht so genau.

Ich bin mir sicher, dass da ganz, ganz, ganz viele Fragen noch offen sind und dass da ganz, ganz, ganz viele Fragen noch kommen werden.

aber so. Ich glaube, den...

Ein bisschen als Einstieg, weil, also ich meine auch,

mir waren da viele Dinge

nicht so richtig klar. Also jetzt, nachdem ich den Artikel

zumindest teilweise so gelesen habe,

dachte ich, ja, okay, da kann man schon coole Sachen mitmachen

und vor allen Dingen kann man das auch,

dass das eben, dass ein Modul auch nur einfach

ein Objekt ist, das ist irgendwie die Eigenschaft,

kann man ja eigentlich total gut ausnutzen, um damit

irgendwie Dinge zu machen.

Aber sollte man.

Sollte man vielleicht nicht, aber,

also zum Beispiel ein tatsächliches Problem,

wo ich halt auch schon so mit Paketen

und Dingen rumgespielt habe, wo ich dachte so,

oh, da gibt es, irgendwie gibt es da keine gute Lösung

für, aber es wäre schön,

eine zu haben, ist halt, oder ich weiß nicht, vielleicht kennst du

eine, ich meine, im Machine Learning-Bereich,

wenn man da Modelle hat, man trainiert die Modelle

jetzt aber nicht, also man hat normalerweise ein

Produktionssystem, was irgendwie dann Dinge

tut, so mit echten Usern und

echten Daten und so,

aber da

entwickelt man ja nicht und man trainiert ja auch nicht

die Modelle, sondern Modelle trainierst du dann meistens irgendwie

in einem Jupyter-Notebook oder so,

dann hast du da dein Modell

und jetzt willst du das irgendwie

aber in deine Produktionsumgebung integrieren.

Wie machst du das denn? Jetzt kannst du

natürlich jedes Mal, wenn du dein Modell trainiert hast,

aber das sind ja oft Dinge, die dann auch periodisch passieren

und automatisch, kannst du

ein neues Paket bauen und das dann releasen.

Aber dieser Deployment-Prozess

ist halt ziemlich invasiv.

Vielleicht willst du

das nicht regelmäßig oder auch nicht automatisch

machen, weil du brauchst Verbrechtigungen

auf irgendwelchen Systemen und keine Ahnung.

Gut, kannst du das natürlich auch, kannst du irgendwie

Deployment automatisieren, was halt so ein bisschen höhe ist.

Und du hast dann ganz, ganz

viele Paketversionen auch

und es ist halt viel,

diese Modelle sind halt teilweise sehr riesig.

Also irgendwie

ist das nicht so richtig schön und

das ist halt die Frage, wie macht man das eigentlich ordentlich?

Und du hast das Problem, wenn man jetzt Sachen pickles,

zum Beispiel auch,

dann ist das

von dem Python-Interpreter abhängig

und so

und der ist möglicherweise in diesem

Jupyter-Notebook-Umfeld, wo jetzt

Data Sciences, irgendwelche Modelle trainieren, halt auch wieder

anders, aus speziellen Gründen anders

als in der

Produktionsumgebung, wo dann die...

Und Pickel kann ja selbst auch Imports durchführen.

Ja.

Du musst ein bisschen aufpassen, wenn man

Versionen nimmt oder so, also Sachen pickelt und dann

Python-Versionen weitergeht, dann geht

das dann mal kaputt, das heißt, das ist nicht mal so einfach

dann... Ja, beziehungsweise auch, wenn du andere Imports

hast oder andere Versionen, Pickel

importiert halt die Sachen, die es braucht und

ja.

Ja, und also das ist

Das kann schon, also da gibt es

diverse Fallstricke und der Weg, den ich dann

irgendwann gegangen bin, ist halt dynamisch

Conda-Pakete zu bauen und weil das

mit Conda relativ leicht ging, aber das war

da kann, ich weiß nicht, ob es da Importlib, doch

Importlib gab es glaube ich auch schon, ich wusste aber nicht so viel

davon, ich weiß nicht genau

und die habe ich dann halt sozusagen als

Django-Modelle

irgendwie als Files irgendwo hingelegt und dann

diese Pakete importiert und dann konnte man einfach

einfach sozusagen sich, konnte man

in einem Jupyter-Notepunkt, wenn man ein Modell fertig trainiert hat

konnte man sagen, deploy mir dieses Modell irgendwie

und dann tauchte das halt auf

und wenn man es ausgewählt hat, wurde es halt importiert.

Und zwar einfach aus...

Aus der Datenbank importiert.

Aus der Datenbank, beziehungsweise nicht aus der Datenbank, sondern

aus der Datenbank plus irgendwie,

naja, nicht in dem Filesystem, sondern in der Filesystemabstraktion

im

Files storage,

und

das geht wahrscheinlich auch

ohne Conda, nehme ich mal an,

wenn ich das jetzt mir so überlege.

Und wahrscheinlich geht das auch noch eleganter,

als wie ich das damals gemacht habe.

Ja, aber also jetzt mal die Diskussionsfrage, warum nicht wirklich aus der Datenbank importieren? Im Prinzip sind da nur irgendwelche Daten, kannst du da als String da reinlegen und kannst sagen, importiere mir dieses Modell, kannst du ein Reimport machen und dann wirst du vermutlich noch so einen Proxy-Pattern brauchen.

Ja, also das Ding für

Conda war dann halt tatsächlich

irgendwie, was ist, wenn ich jetzt irgendeine spezielle

Abhängigkeit habe

in meinem Modell, also ich benutze jetzt irgendeine

neue fancy Maschine

in der Bibliothek, die ich auf dem

Produktionssystem jetzt aber noch nicht habe

Ja, okay, dann stirbt es ab und

Genau, und dann ist halt

kaputt, wie kriege ich das

da mit rein und zwar ohne, dass ich

ja, und das war, über Conda ging das

aber

Ja, okay.

Das ist natürlich schwierig, vor allem wenn du dann Sachen installieren

musst, die du eigentlich, was du an der

Stelle eigentlich nicht willst. Wobei,

also ich meine, Pip gibt es auch als Bibliothek.

Du kannst auch Pip aufrufen

von Python heraus.

Also,

was ich für

meine

interaktive Programmierungssache gemacht habe, ist

eben so ein Proxy-Pattern.

Dass du quasi

eine Schicht dazwischen hast.

weil du möchtest ja

an der Stelle, wenn du es neu importierst,

musst du halt auch ganz viele Instanzen ersetzen.

Eigentlich. Und das ist

schwierig, weil die hast du oft nicht selber in der Hand

oder da kommst du oft einfach gar nicht dran.

Also Instanzen, das heißt, du musst die laden mit dem neuen Kontext

der neuen Importe. Genau, weil

du den neuen Code hast und eigentlich

müsstest du jetzt die... Du musst aber dann quasi ja alle

Transaktionen, die du auf der einen Instanz hast, schon gemacht hast,

schon wieder nachvollziehen, weil du den State ja quasi wiederherstellen musst.

Genau, also genau, das ist die eine Sache,

du müsstest den State quasi wiederherstellen und die andere

Sache ist, du müsstest den Code ersetzen, weil

Ich habe jetzt ja ein m.x und ich möchte aber ein m.x2 haben.

Aber das kann jetzt ganz anders sein, weil du hast jetzt nur m.

Ja, genau, kann sein.

Und dafür gibt es einen Pattern, das heißt Proxy-Pattern,

wo du quasi ein Interface definierst, was da alles drin ist.

Was ist denn ein Interface?

Also du definierst quasi, was ein Objekt kann.

Also ein Typ.

Und die eigentliche Umsetzung ist aber quasi eine Klasse dahinter.

Du definierst quasi den Typ und dann...

Dieser Proxy macht nichts anderes, als diese Aufrufe weitergeben.

und dann kannst du nämlich dem Proxy sagen, ersetz mal deinen Background,

ersetz mal deinen Hintergrund, den Code, ohne den Proxy selbst anfassen zu müssen,

den du halt oft nicht rauskriegst, weil der in irgendwelchen Sachen drin hängt.

Und ich könnte mir durchaus vorstellen, dass das mit so Machine Learning Modellen auch funktionieren könnte,

dass du halt einen Proxy hast, der dieses Modell weg abstrahiert und der kann die Sachen irgendwoher wiederladen,

ob das jetzt aus der Datenbank ist oder aus dem Dateisystem oder sonst woher.

einfach, dass du eine Trennungsschicht drin hast.

Ja, das ist wahrscheinlich auch

der richtige Weg.

Das wäre der richtige Weg.

Ja gut, man weiß das ja

oft zu dem Zeitpunkt nicht so richtig.

Es ist einiges an Verwaltungsaufwand,

so ein Proxy richtig zu machen und

das geht in manchen Sprachen einfacher.

Ein Interface definieren geht

in Java ganz einfach, weil das gibt es da halt.

In Python ist es halt nur eine Klasse,

die lauter Not Implemented Errors hat.

Ja, aber ungefähr so, ja.

Ja.

Ja.

Achso, gibt es zu diesem Projekt, gibt es da eigentlich auch schon einen Link oder sowas?

Nee, demnächst.

Demnächst.

Wird nachgereicht.

Ich liefere das nach.

Okay.

Und jetzt habe ich es öffentlich gesagt, jetzt muss ich es auch wirklich machen.

Das ist immer gut.

Sehr schön.

Ich hatte ja, vielleicht rede ich mich ja noch gegenüber mir selbst, kann ich mich immer

sehr leicht rausreden, aber wenn ich es jetzt schon gesagt habe.

Ja, gib mal auf jeden Fall deine Bucketlist, dann erwähnen wir es mal öffentlich.

Ja, gut.

Das ist gut.

Ja, also interessant, dass man aus so einem Blogartikel

noch alles machen kann. Also wir hatten ja, glaube ich, ja vorher, bevor wir

einen Blog gefunden hatten, irgendwie, und dann war ja irgendwie

ergänzte Information. In demselben Blog habe ich

noch so ein paar andere Sachen entdeckt, die wir auch vorhaben,

sowas wie Datentypen sprechen und wie das implementiert

ist und wie halt das Python-Objekt-System

funktioniert oder die einzelnen Dinge oder

der C-Python-Compiler,

wie das überhaupt geht. Und da müssen wir auf jeden Fall

auch mal drüber sprechen. Aber schaut doch schon mal

in diesen Blog rein, 10.000 Meters Com, das fand ich wirklich

interessant. Ja, da waren einige gute Sachen dabei.

Ja, ziemlich.

Ja, ich habe mir auch dieses

C-Python-Internalist-Buch

besorgt.

Ja,

mal schauen.

Vielleicht kann man da auch noch ein bisschen was rausholen.

Ja, das werden wir auf jeden Fall, also vielleicht

verpusten wir jetzt tatsächlich so jeden dieser Blogposts.

Wir lesen die einfach vor.

Nein, das ist wirklich toll und ich glaube,