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 ausweisend ausgelassen.

Deswegen müssen wir die Episodenummer jetzt ergänzen.

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

Hi Jochen.

Ja, 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-Import-System 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 so ein kleines bisschen mehr vorbei.

Ja, das Problem habe ich auch nicht.

Jochen, erzähl du doch mal, wie fühlt sich das für dich an?

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 erstmal so die Story.

War das eine Pressemeldung?

Es war eine Pressemeldung und es war eine technische

Meldung, glaube ich, dass sie jetzt

CSAM angemacht haben,

Content Scanning.

keine Ahnung, was das 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 Technologie, was

man halt auch nehmen könnte, aber

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.

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.

Aber man weiß es nicht.

Aber es ist ein Präzedenzfall,

dass Apple scannt jetzt Inhalte auf euren Geräten.

Vielleicht ist das die Vorbereitung dafür, dass sie auch in China den Markt

weiter öffnen wollen. Das machen sie ja auch

sowieso schon immer. Also man kann ja auch in der

Fotos-App irgendwie nach, weiß ich nicht,

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

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 das ist tatsächlich, 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 halt, es wird auch nicht an irgendwen geschickt.

Und jetzt ist das natürlich eine andere Sache,

wenn es jetzt eines von den verbotenen Bildern findet,

dann sagt es irgendwie dem Pets, dass das ...

Das sind die leicht verbotenen Bilder?

Ja, wer weiß.

Mit den False Positives?

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, ja.

Na gut, mal sehen, wie sich das entwickelt.

PR-mäßig ist es auf jeden Fall

ein mittleres Desaster. Du hast das von deinem Impfpass gesagt,

das heißt, du bist auch jetzt durch, endlich, vielleicht.

Ich bin schon lange durch.

Ich auch jetzt seit einer Woche, yay!

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?

Ach, egal.

Die Zuhörer will ich machen. Es gab so einen tollen

Rant-Post von

Linus Torweister, glaube ich auch.

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

Ja, genau.

Ja, Linus Torvalds 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 sich 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 haben sie sich zum Beispiel

C-Mac 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

das 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,

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,

ah, 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 Deplication.

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 Richtkandidat oder was.

Die Zahlen, die gehen so schnell hoch.

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. Ich 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

mir die komplette Funktion inklusive Docstrings und Type

Annotations als TypeHint 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,

irgendeine Klasse, Define, Get, bla bla bla.

Und danach fange ich an mit Define.

Und dann schlägt 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 echt mächtig, glaube ich.

Also mir hat das schon echt Zeit gespart zwischendurch.

Ich weiß gar nicht genau, auf welchem Modell ist das?

GPT-3?

Ja, das ist ein GPT-3.

Ja, also da geht einiges.

Also ich meine, das ist vielleicht auch noch ganz interessant.

Das ist so ein kleiner Abschweif,

aber vielleicht auch nicht so uninteressant.

Ich meine, Text ist ja im Grunde deutlich...

Also dachte man ja immer,

Sprache ist halt schwierig,

aber tatsächlich ist das irgendwie einfacher als andere Probleme.

Und wisst ihr, wie diese 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 zu haben zu müssen.

Was man ja normalerweise ist immer das Problem bei,

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

angeschrieben hat, wie zum Beispiel jetzt, wenn man

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 da zum Beispiel so diese

Newsreuters-Artikel und da steht dran, das ist jetzt Sport

oder das ist Politik oder das ist halt irgendwas anderes.

Cool wäre ja so das Label wie

will ich lesen, will ich nicht lesen?

kann man auch alles machen. Spezifisch für dich, Dominik.

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

halt 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, ja.

Ne, 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, 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 Technische Redaktion und

dann Prozesse und keine Ahnung und

Abstimmungen und das kostet ein Schweinegeld und

das macht dann halt keiner so einfach so.

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

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

und die

funktionieren so, dass man

quasi Texte nimmt und lässt

halt jetzt Wörter weg

aus den Texten und lässt das Modell

jetzt vorhersagen, okay, welches Wort gehört denn an die Stelle

und

dann

bestraft man das, dann hat man halt

Feedback, wenn das Modell jetzt ein anderes Wort

als da stand vorher sagt, dann sagt man

okay, das war jetzt falsch und dann kann man

halt irgendwie ein Gradient

bestimmen, in welche Richtung müssen sich die Gewichte ändern

von dem Modell und dann

propagiert man die halt zurück und dann

ändert man das Modell ein bisschen in die Richtung,

dass es das halt beim nächsten Mal besser macht.

Und das macht man 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.

Das ist wirklich cool.

Man kann das gesamte Internet nehmen und

dann lernt das halt lustigerweise

eben nicht nur irgendwie so

stumpf, welches Wort

die höchste Wahrscheinlichkeit hat, da zu stehen,

sondern um das gut machen zu können,

lernt das 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, 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.

Die meandern auch so ein bisschen, oder?

Wenn man halt so ein bisschen Gedächtnis so ein richtiges...

Kann man es sehr 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 einem Menschen geschrieben wurden,

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 sind, die werden wohl bestraft, wenn sie Plagiate erzeugen.

Weil das willst du natürlich nicht.

Du willst natürlich nicht ein Paper einreichen, was dann als Plagiate abrechtet.

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

dieses, dieser Begriff

Colossal Information in Papern

vorkommt und die dann eben genauer

angesehen und die waren alle, hatten eben

alle diese Anzeichen von erzeugten Papern

und das ist so ein bisschen jetzt quasi

die Kehrseite von Co-Pilot, dass die eben nicht

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

Gutes einsetzen und nicht für

Ja, da bist du ja schon

positiv beizuschreiben.

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 hat.

Was? Noam Chomsky würde dir widersprechen, Jochen.

Jaja, gut, aber man kann

sich da ja beschränken, 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.

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.

Es gibt ein bestimmtes Wort wie F,

das fast überall hinpasst.

Ja, klar.

Aber das Modell ist dann halt auch,

das Modell, das damit trainiert wird, passt dann aber nicht mehr

überall hin, wenn du das als akzeptiert

findest, dass das

funktioniert.

Jedenfalls, genau.

Mit Sprache geht das total super.

Und eben, Co-Pilot 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 sozusagen,

das man wirklich hat, adaptieren.

Also da braucht man dann nur noch ein paar

Trainingsbeispiele, also nicht mehr viele.

Ich glaube auch, er macht das tatsächlich anhand

des Reposits, was du gerade aufhast.

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. Naja, und das ist halt natürlich total

toll, weil das dann

halt bedeutet, dass du im Grunde dieses

Trainingsproblem, Trainingsdatenproblem

los wirst.

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.

Also da wird es hier eine Menge interessante

Anwendungen geben. Also gerade für die ganzen

FAUM-Programmierer unter uns, also das ganze Zeug

drumherum, das geht halt einfach jetzt viel automatisierter.

Hatte ich schon gesagt, muss man immer noch selber machen.

Ja, ich bin dagegen, das ist schlecht für die

Auftragsprogrammierer.

Finde ich nicht gut. Ja, 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

sowas, was einem die Forschung

sagt, manchmal Schwierigkeiten hat,

das einfach so zu akzeptieren. Aber

die sagt halt, ja, also 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. Dann fragt man sich, wie machen

die das denn? Ich meine, 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

so eine Art self-supervised learning

machen und quasi genau

das gleiche Prinzip irgendwie,

also sie 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.

Naja, keine Ahnung. Ja, aber das zieht

das dann irgendwo aus dem Äther, irgendwelche Formationen

schafft das dann dazwischen 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 überschreibt.

Einige Leute, die haben dann auch

innere Stimme, die dann auf einmal selbst vervollständigt, die

nur so halb gehört haben. 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.

Willst du jetzt zum Topic zurück?

Nein, nein. Nur ganz kurz, also das, was halt

momentan nicht geht, was man nicht hinkriegt,

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,

ein 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 weist 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?

Da 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 das,

wie man da die Wahrscheinlichkeit

ausrechnen soll.

Ja, vielleicht braucht man dafür echt einen Kontext,

der das eingesetzt werden soll. Das 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 war so 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, Entschuldigung, es 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

Preis- und Importsystem 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 Preis- und Importsystem?

Ja, ich habe diesen Artikel auf Hacker News gesehen

und auch die Diskussion dann so ein bisschen.

bisschen angeguckt und

da ist mir aufgefallen,

dass das doch tatsächlich erstaunlich viel

komplizierter ist, als man

das so denkt oder als man das so 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? Könnte das sein?

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

und doof sein kann. Worum geht's 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.

Ja.

Wer will anfangen?

Also ich würde sagen, ja, vielleicht kann man

genauso anfangen wie der Artikel. Was passiert denn,

wenn man sagt Import M?

Warum sagt man das denn überhaupt, Jörg?

Warum sagt man Import M?

Ja, 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

eine einzige Feier. Also 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?

Hat auch einen ähnlichen Effekt irgendwie.

Ja, genau. 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, das macht ja so ein

Namespace wieder. Ja, genau, das müsstest

du dir dann, also wenn du einfach die Datei lädst

und ausführst, also

IWR drauf machst, dann

ja, drückst du halt erstmal alles in die Hand.

Und da wäre dann, hätte man

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

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

derweil

importieren und e-wählen 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

muss man 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

inkludierst, die 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 Pre-Processor 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

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

Sachen ausführen.

Was

manchmal komisch ist und manchmal gewünscht

und manchmal überraschend.

Ja, also das ist manchmal

tatsächlich, wenn man Sachen importiert,

dass 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

ein Import schreibt, 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 man könnte auch ein Modul laden,

was halt, wenn ein Modul heißt, das M heißt,

das in einem Verzeichnis ist oder sowas.

Oder was ist ein Modul?

Nee, das wäre dann wieder was anderes.

Ja, aber ein Verzeichnis ist ja auch nur so eine Art Datei.

Ein Verzeichnis ist ja auch nur ein Verweis auf die InitPy.

Also es gibt Module und Packages.

Und was ist denn überhaupt der Unterschied?

Was ist 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 Init-Pi, die da drin ist, dass der Inhalt

dieses Verzeichnisses ist.

Genau, in der Init-Pi

kann man auch sowas wie All dann definieren, das heißt, wenn man zum Beispiel

sowas wie Import-Aspects, das kannst du auch

in einer einzelnen 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 import Stern

ja so

verpönt ist. So gerne gesehen wird.

Es riecht.

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.

Import Stern habe ich noch gar nicht probiert.

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 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 Sachen,

die es 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 über, 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.

Ja, aber ich glaube,

es ist auch irgendwie,

ich glaube, der entscheidende

Unterschied ist, dass irgendwie ein Paket Submodule

haben kann und ein Modul nicht.

Also genau,

ich habe eine Definition gefunden bei

der irgendwo sagt hat dann,

if a module name has no dots, it's not

considered to be part of a package.

Aha.

Ja, okay.

Mag sein.

Also ein Paket ist halt quasi eine Sammlung von

Modulen oder sowas.

Okay, gut.

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

offensiv sind die 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. Ja. Von wo importiert

er 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. Wo ist das denn? Ja, genau.

Und zwar auf dem Python

Path. Auf dem Path, ah.

Da gibt es eine Variable, die heißt

sys.pythonpath.

Sys.path. Sys.path heißt die, oder?

Okay, ich weiß, ich vergesse es jedes 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,

das ist entweder vorne oder hinten, das ist immer

Ich glaube 0, der erste ist immer

wo du gerade bist. Das ist immer 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 eins, wo ab da was drin ist.

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, das

Installationsverzeichnis 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.

Ja, also da sind einfach viele Verzeichnisse drin.

Also wenn man verschiedene Pakete haben will, die auch importiert werden können,

dann muss man einfach da gucken. Das ist ein

sys.path quasi in der Umgebungsvariante

Das ist im Wesentlichen das, was Virtual

Env 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 Init-Pi hat, oder in Python 3

ein Verzeichnis, was

das M heißt und Python-Dateien

enthält, was keine Init-Pi 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 diskutiert,

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.

Also früher musste man ja immer die Init-PUI haben.

Vor allen Dingen deswegen,

damit halt nicht Verzeichnisse,

die halt so heißen wie ein Standardmodul,

halt 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 Init-Py 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

Standard-Bibliotheks-Module

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 Rang-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 weiter.

Wo der Pycache und so weiter noch was dann kommt, aber egal.

Genau.

Aber man kann halt

auch, es gibt auch Verzeichnisse und denen

wird auch gesucht, wenn da keine 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 erhalten

fest, einfach immer eine Init-Pile.

Ja, dann ist es sicher.

Aber so kannst du halt

auch Dinge in einem Paket haben, die in unterschiedlichen

Verzeichnissen liegen, was halt manchmal auch ganz praktisch ist.

Klar. Man kann das schon brauchen.

Ja, okay.

Okay, also was ist dann

das haben wir gesagt, Package, es gibt auch

ein dann dann Package, was steht

denn da?

Ist das Current Package? Genau.

Ja, das ist das aktuelle Paket.

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

Ja, äh,

oh Gott, ich weiß auch nicht, ist es auch so? Ich glaube, also wenn es

None ist, dann ist es ein Skript.

Also vielleicht noch mal zu distinguieren zwischen Skript-Modul

und Pakete oder so, wenn Package None ist,

das ist nur ein Skript und wenn, er sucht halt dann, ob er 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 gerade gesagt hast.

Ja, die liebe ich. Relative Importe sind voll gut.

Ab und zu vertippt man sich ja mal oder hat irgendwie.

Ja, aber 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 Punkt Import

irgendwas, also from Punkt Import M.

Oder vom dot dot.

Oder auch from Punkt 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. Ja,

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 Package,

wenn man ein Paket finden kann, also ein Top-Level

finden kann, ja, 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... Okay, das kann natürlich sein.

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. Aber, 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ührst,

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

Wenn du diese Datei

direkt aufrufst. Genau. Das kann man übrigens

verhindern, indem man einfach sagt, Python minus M

und dann dieses Modul dann

innerhalb von dem Pfad aufrufen. Genau.

Die meisten meiner Projekte sind ja aber in einem Django-Umfeld.

Ja. 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, ja,

musst du ja richtig definieren. Ja, aber der

Pfad ist immer festgemacht an der Manage-Pile.

Genau. Das heißt,

das weiß ich. Ich weiß, wo der Pfad...

Ja, aber das ist ja auch Python-M, 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

in einem anderen Verzeichnis. Also da gibt es

sind Tests 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. Ja, genau, klar.

Und wo es mir halt auch ab und zu passiert ist,

ist halt 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 Importer

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... Ach so, wenn der Name des

Moduls, also wenn das Modul quasi

m.x.y.

Genau, dann ist es halt

ein Part, ein Paket.

So was vermeiden wir jetzt einfach halt noch.

Ja genau, aber nein, andersrum, wenn es halt keinen Punkt

mehr hat, dann muss es eigentlich schon

Top-Level sein, weil dann

kannst du ja nicht.

Ah, okay.

Aber man kann ja jetzt auch so Dinge tun

wie, man sagt

from m import

x oder so.

Habt ihr schon mal Skriptnamen mit Punkten verwendet?

also mit mehreren Punkten drin.

Nee, das ist das, was ich gerade jetzt überlege,

ob ich eine Datei mit Punkten drin hätte,

ohne also Punkt P, Y.

Ich glaube, das kann zu Problemen führen, oder?

Ich glaube auch, dass das zu Problemen führt.

Und das würde ich auch vermeiden einfach.

Ja, interessant.

Stimmt, das habe ich auch noch nicht ausprobiert.

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

Was passiert eigentlich, wenn man einen Punkt eingibt?

Ja, genau.

Ach so, 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 ein 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, ja, from M Import X.

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

noch gleich ein bisschen anders. Also man muss

eigentlich immer auf die Datei zeigen, die man

haben möchte. Ja, aber genau, das fand ich auch

Das hat mich auch überrascht, das wusste ich nicht,

wenn man sagt, vom M-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,

weil dann holt er sich doch noch die Detail.

Ja, ja, ja.

Achso, und es ist natürlich alles übrigens noch gecached.

Ja, also man kann so oft Import M machen,

möchte es wird nur einmal gelesen die datei und das wird da wo wir das dann reingeschrieben in

das dictionary der offenen der geladenen module das heißt irgendwie punkt das ist auch so eine

eine geschichte das kann man auch schön sehen

verwenden. Also

manchmal braucht man ja, also Singleton,

ein ehrlich gesagt überschätztes

Cooles.

Es hat einen total coolen Namen, deswegen wollen

es die Leute immer verwenden. Aber tatsächlich gibt es

manchmal braucht man das. Manchmal braucht man es

tatsächlich. Meistens nicht. Meistens

eher nicht. Genau, 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 wird es aber schon

hakelig, dann kann man das irgendwie, dann muss

man schon so Meta-Klassen oder sonst irgendwie sowas,

muss man so Dinge, wo man sich hinterher so ein bisschen

schmutzig fühlt, irgendwie machen und

bis ich dann irgendwann mal, ich weiß 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.

Moment, das muss man ja nochmal genau erklären,

warum das ein Singleton ist. Aber Jochen, wenn du dann

wenn du dann das Pattern richtig ausführen musst,

musst du dann noch in dem Modul noch ein Get

irgendwas machen.

Falls das anlegt oder

Falls jemand

versucht darum rumzukommen.

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 dann

zurück, wenn es schon gibt. Und sonst stellt er 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.

Immer.

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.

Okay. Und Singleton kriegt mir

eben durch ein 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 Punkt 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.

Also, weil das Moment, also das,

weil dieser Import, das ist ein, was ist das?

Ein Modultyp dann, wenn du ein Modul hast?

Genau, das heißt Module.

Und dieser Modultyp ist einfach die Zeichenkette,

keine Ahnung, von dem, was ist?

Ja, das Ausgeführte, das ist eigentlich der ausgeführte Code,

der da drin ist, mit so einer Closure, die außen rum.

Weil sonst könntest du keine Daten haben.

Aber das wird dann doch gecastet, was dann Eval wäre?

Oder, das habe ich ja nicht genau klar.

Ja, im Endeffekt macht es ein E-Wahl, ja.

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 E-Wahl 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.

Er lädt sie einmal.

Aber wenn ich aus mehreren Stellen das habe,

was ist denn dann passiert?

Beim ersten Import Singleton wird diese Datei geladen

und ausgeführt. Ja. Und das

Ergebnis dieser Ausführung wird als Module

Singleton. Ja. Abgelegt

in diesem SysModules Cache.

Und vielleicht wird dann da ein PyCache draus gebracht,

PyC-Files oder so, hat das direkt da?

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.

Beim ersten Import lädt er das

tatsächlich in den Pycify rein.

Das heißt, er macht aus Bytecode draus,

er komponiert das quasi und er liest das

quasi einmal aus als String und man

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 das war jetzt ein Marshall-Objekt?

Nein, das Ergebnis der Ausführung

ist das, was dann das Modul ist.

der Code des Moduls kann dann schon

wieder weg sein, weil den brauchst du dann gar nicht mehr.

Wenn du irgendwo ein Dev machst oder ein Class machst,

da sind dann so Bytecode-Objekte

dran, weil die müssen ja nochmal ausgeführt werden.

Aber das Modul selbst,

das, was in der Datei

drin steht, das muss gar nicht mehr da sein.

Also wenn du einfach nur eine Datei hast, die ganz viele Sachen

ausrechnet und am Ende

aber nur ein Wert rauskommt, dann ist

dieser Code nicht mehr da. Es ist nur noch

das Ergebnis da. Also das Ergebnis

der Ausführung dieser Datei ist dann das, was

in das Modul. Okay, und was

wird dann in die PyC-File reingeschrieben?

Die PyC-Files sind so eine

Zwischendurch-Optimierung, weil die

die enthalten

so einen vorkompilierten Bytecode und der

ist schneller zu laden als eine .py-Datei.

Und das ist ein Marschalt-

Object, also wir hatten 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,

es ist 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 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

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 nimmt, glaube ich, sogar Dill oder sowas,

dass man irgendwie import Dill as Pickle

oder so, also neue Version.

Als Third-Party-Package irgendwie.

Schön.

Okay, aber ein Marschalt-Objekt, falls ihr das irgendwo findet,

ist quasi eine serialisierte

Form von dem

Speisen-Code, der da gelaufen ist.

Genau.

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.dott, dann dann import.

Dann dann

crawl. In diese Funktion

kommen dann halt die Argumente rein, die

Ja, nee, das kann ja alles möglich sein.

Du kannst ja auch beliebige Objekte in der Datei

reinschreiben. Du 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 ein

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.

Der Path ist da drin und

der ursprüngliche Importname

und der Dockstring wird rausgelesen

und so weiter. Also diese ganzen Sachen, die halt

so passieren, wenn Python was ausführt,

die passieren da auch.

Alles, was Python langsam macht.

Alles, was Python awesome macht.

Ja.

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 nicht 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, ja, es ist quasi wie 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 bei Import aufgerufen, 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, ganz weit unten.

Es gibt Importlib und in Python 3 irgendwas hat auch dieser Prozess, 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 Punkt, keine Ahnung, unterstrich 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 noch.

Oh ja.

Wenn man etwas neu laden möchte.

Weil

wir haben ja eben besprochen, wenn ich Import M

mache, dann kriege ich immer das, 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

ein Re-Import 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 Entwicklungs-Server von Django,

der kann sowas ja auch.

Ja, aber der macht ja einen Neustart.

Der macht tatsächlich einen Neustart, na ja.

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, 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.

Ja, ja, das, ja.

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 so 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.

Neu starten wäre auch blöd.

Ja, geht ja auch

an der Stelle einfach gar nicht.

Zum einen, weil der Prozess ja da

läuft und zum anderen, weil

du ja die anderen Zellen nicht kaputt machen willst.

Du hast ja die Zellen immer noch.

Ich hatte übrigens tatsächlich jetzt

letzte,

vorletzte, ne, letzte oder vorletzte, ne,

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?

Ich habe einen Pull-Request

bei Wagtail Media

eingereicht, weil es nicht mit

Wagtail 2.13 kompatibel war.

Spannend.

Ja, da gibt es Tests

und das Problem ist jetzt,

dass man jetzt in den, 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 Backtail

2013. Okay.

Und da sagt man halt, probier 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-to-Py

und Accept-Parse.

Genau, genau.

Und jetzt möchten wir das aber testen.

Jetzt möchten wir testen, dass wenn

und es gibt da noch komplizierter

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

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 Importfunktionen

überschrieben und dann in der Importfunktion 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 Dummy-Objekt? Ja oder nein?

Und dann hat man einen Test dafür.

Ja, aber...

Das ist ja spannend, aber das ist auch ganz schön tief

eingegriffen in die...

Hat der Jochen auch schon 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, aber es kann ja 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

aufeinandersetzen. 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 das 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 dass es möglich ist.

Ich wüsste

jetzt tatsächlich keinen richtig sinnvollen

Anwendungszweck davon, aber

naja,

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

zu Python gemacht. Dann hat man noch

einen Server, irgendwas, was WebAssembly kann.

Man kann Python

schreiben für Frontend. Und schon

eigentlich, deine Dateien

bestehen quasi nur noch aus Import-Statements.

Alles wird 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 ausfalten 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 können auch...

Ich glaube, das Schwierigste an diesem Importsystem

ist, dass es halt manchmal überraschend ist, ja, 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 auch 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 ja C, D, E,

F, G und Y. 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 C und C von A.

Ja, genau, und das hat man ja manchmal.

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

Ich meine, dass da so ganz, ganz, ganz viel Zeugs importiert ist.

Also du könntest ja quasi eine Sache importieren,

und der importiert alles andere, die ganze Standardbibliothek.

Ja, klar. Im Prinzip machst du das ja so in deinem Skript.

Genau, und das ist halt so relativ getarnt, was da passiert.

Man macht relativ viel Magie schon.

Und ja, also was halt die komplizierte Frage wäre,

ob das das irgendwie dann doch langsam macht,

wenn man irgendwie sowas raussucht und sagt,

okay, beim ersten Mal schon.

Das heißt, da kann der Starten relativ lange dauern

und beim zweiten Mal dann vielleicht nicht.

Aber es gab irgendwie so ein Problem,

das irgendwer hatte, der das mal ausprobiert hat

wegen den Imports.

Ja, ja, ja. Also das Problem gibt es,

wenn du halt irgendwie so auf die Richtung,

weiß ich nicht, Millionen Zeilen Python

oder so zugehst, dass eben dann, wenn das zum Beispiel

im Entwicklungsserver, wenn der neu startet,

wenn du so änderst irgendwas, dann startet der neu.

Und dann dauert das halt eine Minute.