Transcript: PP01 - Die erste Sendung

Ja, hallo liebe Hörerinnen und Hörer. Willkommen beim Python-Podcast. Allererste Folge, allererste Episode.

Wir wollen euch heute ein bisschen fügen und folgende Fragen beantworten. Was machen wir eigentlich und warum?

Wie finde ich einen Einstieg in Python? Also, wenn ich Anfänger bin, wie kann ich damit anfangen?

Und geben ein paar Anfängertipps. Und dann wollen wir noch ein bisschen erklären, wie Python funktioniert.

Ein paar Mythen über Python klären und so weiter.

Wenn ihr Fragen, Anmerkungen zu dem Podcast habt, Kommentare, alles was gut ist, was schlecht ist, dann sendet doch einfach eine E-Mail an hallo-at-python-podcast.de

Und ja, Links und zusätzliche Shownotes zur Sendung findet ihr natürlich in den Shownotes.

Ja, was machen wir eigentlich? Kleine Einführung?

Ja, genau. Vielleicht können wir uns einfach kurz vorstellen oder so.

Ja, also wir sind auf jeden Fall aus Düsseldorf, aus dem wunderschönen Wintergarten von Jochen, den ihr gerade kurz gehört habt.

Ja.

Wer sind wir denn? Hallo Jochen.

Hallo Dominik, genau.

Mein Name ist Jochen, der die wirklich wunderschöne Anmoderation gerade kam von Dominik.

Und genau, ja, wir benutzen beide Python und ich höre auch sehr viele Podcasts.

Und im englischsprachigen Raum gibt es da durchaus einige ganz gute Podcasts, die man da hören kann.

Aber ja, zur deutschsprachigen gab es immer mal wieder Versuche, aber letztlich momentan, soweit ich weiß, jedenfalls kein.

Der kontinuierlich aktualisiert wird.

Und ja, da dachte ich, na gut, wenn es niemand macht, dann kann man das ja vielleicht einfach selbst mal probieren.

Und ja, dann habe ich mich so ein bisschen herumgefragt, ob es Leute gibt, die das vielleicht auch gerne machen würden.

Und ja, so sind wir dann zusammengekommen.

Und ja.

Wie kamst du zu Python, Jochen?

Ja, das ist jetzt auch schon eine Weile her.

Irgendwann so 2000, Anfang der Nullerjahre sozusagen.

Ich war ursprünglich da eher so auf der Perl-Seite und dann war aber die, ich habe damals bei Web.de gearbeitet und die Firmensprache da war dann halt aber Python.

Und dann wurde mir nahegelegt, die Dinge, die ich da gemacht habe, irgendwie doch eher in Python zu machen als in Perl.

Und dann habe ich das erst so ein bisschen so gedacht, na gut, ob ich das wirklich toll finde.

Aber relativ schnell war ich da ziemlich begeistert von Python und mache seitdem eigentlich nur noch Python und kein Perl mehr.

Du bist schon ein ziemlich alter Hase.

Ja, das muss man so sagen.

Ja, alter Sack.

Genau, und ja, in unterschiedlichen Bereichen habe ich das jetzt schon so verwendet.

Und daher, ja, denke ich, ist es vielleicht auch ganz, kann ich da auch so ein bisschen was zu erzählen, was man mit Python alles machen kann.

Ja, deswegen bist du da, Jochen.

Also ich gehe davon aus, dass du mir alles erklären kannst, was ich an tollen Fragen habe.

Ich möchte nämlich noch jede Menge wissen.

Genau, und wie bist du zu Python gekommen?

Ja, ich bin ein türmischer Rookie noch.

Ich bin jetzt insgesamt...

Ich war anderthalb Jahre irgendwie bei Python dabei und interessiere mich vor allem für, ach, vielleicht ein paar Buzzwords, Data Science und Digitalisierung, was man damit so machen kann.

Ich habe zwar auch schon damals in der Schule angefangen mit ein bisschen Programmieren und war seit 96 in der Internet-AG.

Das war damals ganz besonders fancy und habe Webseiten da gebastelt und so ein Krams.

Habe dann aber einen ziemlich längeren Umweg gemacht über die Volkswirtschaftslehre, bis ich dann tatsächlich vor anderthalb Jahren mich dazu entschlossen habe, irgendwie nochmal einen ganz neuen Weg zu gehen.

Ein Umdrehen von vorne beginnen.

Und das zu tun, was mir wirklich am Herzen liegt.

Eigentlich wollte ich nur ein paar Daten analysieren.

Und ich bin dann über ein Python-Tutorial gestolpert.

Ja.

Und nach ungefähr 20 Minuten hat es mich dann irgendwie ziemlich vom Hocker gehauen und erwischt.

Und ich wusste, dass es genau das ist, was ich in Zukunft machen will.

Und so bin ich bei Python gelandet.

Ja, von einfach mal nur ein paar Daten analysieren zu, ja, neue berufliche quasi Herausforderungen.

Da klopft jemand an die Tür.

Das ist halt ein Spielzeug in der Hand.

Mhm.

Okay.

Nun gut, ich hoffe, das stört nicht so weiter.

Ja, das ist auf jeden Fall ein schneller Einstieg gewesen, als wenn das nach 20 Minuten schon geschnackelt hat.

Wäre jetzt ein bisschen länger gedauert, aber ja, das ist auf jeden Fall eine gute Sache, glaube ich.

Das war wirklich so.

Ich kam da rein, habe den ersten Code geschrieben und habe gedacht, ja, genau, das wollte ich dann machen.

Stimmt.

Hammer.

Also das liegt bestimmt auch vielleicht an der Einfachheit der Sprache, aber da kommen wir vielleicht ein bisschen später zu.

Was für Features?

Was für Features Python alle hat?

Ja, vielleicht fangen wir nochmal an.

Warum machen wir das eigentlich?

Für wen ist denn dieser Podcast genau?

Was glaubst du?

Für eigentlich jede, die sich für Python interessiert, oder?

Ja, ich denke schon.

Also das ist halt auch so ein Ding, dass Python momentan halt sehr viel an Popularität gewinnt.

Also ich meine, das hat es schon immer getan.

Also es war schon immer recht populär, aber in letzter Zeit gerade eben über Data Science und verwandte Themen,

Machine Learning, Deep Learning.

Und Dinge, die halt auch sonst sehr stark gehypt werden, ist Python halt sehr, sehr groß geworden.

Und mittlerweile hat es halt irgendwie Ausmaße angenommen, die dazu führen, dass es jetzt eine ganze Menge Leute gibt,

die das gerne lernen würden oder sich dafür interessieren.

Aber wenig Angebote sozusagen, diese ganzen Leute irgendwie abzuholen.

Und ich denke, da können wir auf jeden Fall eine Menge Hörer ansprechen, sozusagen.

Und aber ich würde das nicht unbedingt auf Anfänger beschränken, sondern einfach mal so quer durch alle größeren Themen oder so, die es gibt.

Wir hatten uns ja auch schon so ein bisschen Gedanken zugemacht, was man da alles mal,

worüber man, über welche Dinge man mal so eine Sendung machen könnte.

Und da haben wir auf jeden Fall genug Stoff zu senden.

Und da können wir auch gerne mal so richtig fies ins Detail gehen.

Ja, genau. Also ich glaube, bevor wir euch erzählen, was wir heute denn genau so machen,

wir haben ja einen kleinen Einstieg schon gegeben, gibt es tatsächlich diese ganzen vielfältigen Themen in Python.

Und wir wollen jetzt tatsächlich in mehreren Episoden euch das ganz Interessante mal so ein bisschen berichten.

Über Django, über Datenbanken, über Python Performance, über Machine Learning und ein bisschen Data Science,

MicroPython, es gibt ziemlich einiges, was wir jetzt hier auf dem Zettel haben.

Können also auch ein bisschen gespannt sein, was wir so machen.

Ja, was machen wir heute? Das ist der Einstieg in Python.

Genau, einfach mal so eine Übersicht.

Genau, und dazu haben wir vielleicht erst mal ein paar kleine Fakten über die Geschichte.

Dann kann Jochen bestimmt noch viel mehr zu erzählen als ich.

Aber soweit ich weiß, hat Guido van Rossum die Sprache entwickelt in den frühen 90ern.

Und zwar aus Amsterdam, das herausentwickelt.

Ja, also ist schon gute, wie lange?

Fast 30 Jahre halt, würde man gar nicht denken.

Python 3, das wir alle nutzen, ist seit 2008.

Und falls irgendwelche Nachfragen kommen, ja, wir finden nur noch Python 3.

Ich glaube, das hat sich mittlerweile so eingebürgert.

Die neueste Version ist jetzt erst im Oktober erschienen, 3.7.1.

Und für nächsten Herbst ist, glaube ich, 3.8. geplant.

Also wir sind im Jahr 2018 für alle Menschen, die das irgendwann später...

Ja, also Jochen, im Laufe der Jahre hat sich ziemlich viel getan in der Sprache, oder?

Ja, wobei erstaunlich viele Dinge auch recht ähnlich geblieben sind.

Also ich meine, das ist halt auch möglicherweise einer der Unterschiede zu Sprachen wie...

Jetzt nehmen wir mal JavaScript oder so, wo sich halt in letzter Zeit sehr viel getan hat.

Und man dann immer...

Also ich mache in letzter Zeit auch irgendwie ganz schön viel JavaScript.

Und oft muss ich dann, wenn ich jetzt irgendwas mache...

So, wie iteriert man denn jetzt nochmal über irgendwie quasi die Keys und die Values irgendwie in einem Hash oder so?

Wenn man danach guckt, dann findet man halt...

Zu jedem Jahr quasi und zu jeder neuen ECMAScript-Version eine andere Art, wie man das am besten jetzt tun sollte.

Und da ist Python eigentlich sehr, sehr stabil geblieben.

Das ist heute noch...

Ja gut, an der Stelle hat sich auch tatsächlich was geändert, aber sehr moderat und mehr oder weniger so vorschleifend.

Das ist halt von Anfang an so, wie es jetzt heute auch noch ist.

Also es hat sich seit 30 Jahren im Grunde nicht großartig geändert.

Wobei es da auch nicht so wirklich Bedarf gibt für eine Änderung, weil es war einfach von Anfang an...

Aber Antupa implementiert.

Ja, ich glaube, ja genau, 1991 ist das irgendwie gestartet.

Und ich weiß gar nicht, ob ich da so wahnsinnig viel zu erzählen kann, weil damals war ich auch noch nicht dabei.

Das habe ich auch alles nicht so richtig auf dem Schirm, was da passiert ist.

Ich habe irgendwann angefangen...

Also die erste Python-Version, an die ich mich erinnern kann, mit der ich irgendwie Dinge gemacht habe, war so, glaube ich, 1.5.2 oder so.

Das muss irgendwann Ende der 90er gewesen sein.

Da habe ich aber kaum mit Python...

Also da habe ich nicht wirklich Python gemacht, um Python zu programmieren,

sondern habe es halt verwendet in irgendwelchen Skripten und so.

Oder irgendwelche Skripte angefasst.

Und dann später so wirklich angefangen, damit größere Dinge zu programmieren, habe ich dann mit Python 2.1 oder so.

Das war die Version, in der ich die erste größere Geschichte geschrieben habe.

Was würdest du sagen, war so der größte Unterschied zu heute?

Der Umfang der Standardbibliothek?

Ja, natürlich, da ist einiges dazugekommen.

Aber das ist gar nicht so...

Ja, so was halt...

Ja, so diverse Sprachfeatures, also Generatoren, ich glaube, die kamen irgendwie mit 2.2 oder so.

Das ist heute doch etwas, was man viel mehr benutzt, als man es damals getan hat.

Überhaupt, ja, diverse Keywords, Yield, aber...

Ja, das stimmt, aber das ist auch schon relativ lange da.

Also ich weiß nicht, wann 2.2 rauskam.

Müsste irgendwann 2002, 2003 irgendwann gewesen sein oder so.

Was heute eine große Rolle spielt, und damals war das halt alles noch gar nicht da, ist alles, was irgendwie mit AsyncIO oder irgendwie, ja...

Wann kam das anfangen? Version 3, FHRs, oder von 2?

Nee, nee, die Syntax dafür, also das ist jetzt erst in 3.5, glaube ich, mit dazugekommen.

Und da hat sich auch noch was zu 3.6 geändert.

Gab es da vorher ein externes Modul für?

Ja, es gab schon immer irgendwie externe Module, mit denen man solche Dinge machen konnte, sowas wie Twisted oder G-Event.

Habe ich auch eine ganze Zeit lang verwendet.

Ist auch toll, aber das Problem ist, dass man, ja, quasi, wenn man dann auf eine dieser Bibliotheken aufsetzt, halt in seiner eigenen Welt mehr oder weniger gefangen ist.

Und wenn jetzt jemand anders was geschrieben hat, das auf Twisted, weil ganz viele Leute haben Twisted halt als Basisbibliothek für ihre Netzwerkkram benutzt.

Aber man kann das dann halt nicht einfach so verwenden, weil wenn man jetzt selber auf was anderem aufsetzt, dann geht das halt alles nicht.

Und das war kein so wirklich schöner Zustand.

Es war auch nicht total furchtbar, das ging alles.

Und man konnte...

Also irgendwie mit Threads konnte man auch eigentlich quasi das schon immer machen.

Irgendwie so IOMultiplexen, das ist halt das, was man vor allen Dingen macht, wenn man jetzt irgendwie quasi so asynchronen Dinge tun will.

Aber so wirklich schön war das alles nie.

Und jetzt inzwischen gibt es da halt eine nette Syntaxführer und das ist eigentlich ganz toll und das machen ganz viele.

Und genau, das war damals alles noch ganz weit entfernt.

Achso, auch damals, was dazugekommen ist, Newstyle-Classes.

Was?

Newstyle-Classes.

Newstyle-Classes.

Genau, die Klassen waren etwas anders davor.

Ja genau, jetzt müsste ich noch nachlesen, was da genau die Unterschiede waren.

Ich glaube, eigentlich weiß ich nur, dass man halt quasi dann immer nicht Doppelpunkt, also Lehrzeichen, Klassen-Name, Doppelpunkt geschrieben hat.

Sondern irgendwie die ganze Zeit lang hat man immer...

Auf Object geschrieben, damit es halt von Object erbt und man Newstyle-Classes automatisch verwendet.

Was man jetzt halt auch schon eine ganze Zeit lang nicht mehr tun muss.

Von jeder Klasse automatisch von Object dann, oder?

Ja, genau.

Und dann gibt es natürlich noch diverse Meta-Programmierungsgeschichten, Meta-Classes und so.

Ich weiß gar nicht, wann die dazugekommen sind.

Das gab es, glaube ich, am Anfang auch nicht.

Ja, dann...

Achso, auch eine neue Syntax, die sehr praktisch ist.

Das ist halt so...

So...

Also es gibt List Comprehensions, glaube ich.

Das gab es auch nicht, seit wann?

Die gab es bei 1.5 noch nicht.

Es gab es bei 2.1, sind die, glaube ich, dazugekommen.

Also jedenfalls, als ich angefangen habe, war das so, das war so eine neue Geschichte, die dazugekommen ist.

Dann kam, glaube ich, mit...

Dann weiß ich ja nicht, wann die Generator-Expressions dazukamen, wo man halt nicht eine List Comprehension hat, sondern dann quasi runde Klammern schreibt und dann das Ganze in Generator ist.

Das könnte sein, dass das erst mit 2-4 war oder so.

Und jetzt gibt es auch irgendwie so...

Syntax für Dict-mäßige Objekte.

Also man kann halt auch geschweifelt Klammer auf und dann V, K, V in irgendein Dict.items sagen.

Und dann würde sich...

Also kann man sich seine Diction erst generieren.

Ja, genau.

Und muss dafür nicht extra irgendwie nochmal Dict aufrufen oder so.

Ja, das ist jetzt...

Das ist aber dann relativ spät dazugekommen.

Ich glaube, es ist erst mit Python 2, 3 oder...

Äh, Python 3 dazu.

Äh, äh...

Dazu gekommen jetzt.

Wofür nützt man denn jetzt eigentlich Python heute?

Ja.

Insgesamt.

Vielleicht machen wir das nochmal als Frage für unsere Hörer, die das so genau wissen wollen.

Äh, genau.

Also am Anfang war es vor allen Dingen eine Skript-Sprache zum Verbinden von irgendwelchen Systemen.

Man hat das halt so...

Ja, man nennt die Dinge auch Glue-Languages und so, weil man halt...

Weil es schön einfach ist, diverse andere, ja, in anderen Sprachen programmierte Libraries anzubinden und die dann halt irgendwie miteinander zusammenzubinden.

Also verschiedene Server-Module mit Python-Kleis dazu geklebt.

Ja, irgendwie sowas wie, man hat ImageMagick oder so eine Bibliothek, die jetzt auf Bildern irgendwas macht und hat dann halt irgendwelche Bindings, die das in Python verfügbar machen.

Und dann hat man irgendwie eine Bibliothek, die irgendwie Mails macht oder dann kann man irgendwie E-Mails mit Bildern oder so dann irgendwie verknusteln und dann irgendwie...

Ja, E-Mails mit Bildern drin verschicken oder sowas.

Und solche Sachen hat man halt in Python vor allen Dingen gemacht.

Okay, da hat man halt ein Bild in der Hand und man hat einmal ein E-Mail in der Hand und Python gibt dann den Kleber, dass man ein E-Mail mit Bild...

Genau, ansonsten wenn man jetzt, keine Ahnung, irgendeine Bibliothek hat, die in Zyklospos geschrieben ist oder so, wenn man da jetzt irgendwie E-Mail-Support einbauen will oder irgendwie eine andere Bibliothek, die mal was anderes geschrieben ist, die einbinden will, das ist halt sehr schwierig.

Und mit Python kann man das alles sehr schön integrieren.

Also für sowas hat man es vor allen Dingen verwendet, aber auch für Web-Entwicklung von Anfang an.

Eigentlich schon, soweit ich weiß...

Welche Frameworks haben wir da groß? Also ich kenne jetzt zum Beispiel Flask, habe ich in einem Doktor gelehnt, und natürlich Django.

Ja, die kamen allerdings sehr viel später.

Also, sagen wir mal so, es wurde halt auch als CGI verwendet.

Als was?

Es gab es ganz früher, das ist schon fast ein bisschen Opa als Held vom Krieg-Sektion.

Ja, das ist ja deswegen natürlich hier.

Es gab das Common Gateway Interface.

Das war halt eine...

...Methode, wie Web-Server sozusagen Skripte aufrufen konnten, die dann irgendwie...

Also, am Anfang gab es nur...

Am Anfang waren statische Seiten, wo halt ein Web-Server irgendwie eine Datei ausgeliefert hat.

HTML pur.

Ja, und das ist aber ein bisschen wenig, wenn man jetzt also sowas hat wie eine Webseite mit einem Gästebuch.

Sowas gibt es heute auch alles nicht mehr, aber damals war das halt so.

Da musste man das haben.

Da musste man irgendwie einen Encounter haben, der irgendwie...

Da hat er sein Gästebuch rum und rein.

Ich war bei dir im Internet.

Genau.

Ich habe da was reingeschrieben.

Ich habe es benutzt.

Ja, und das geht natürlich mit statischen Seiten irgendwie nicht.

Also, wenn ich jetzt so ein Gästebuch habe und ich habe da ein Feld, wo ich irgendwas eingeben kann

und dann soll das halt irgendwo gespeichert werden, dann muss sozusagen der Text, der

in dieses Feld geschrieben wurde, irgendwie durch ein Skript durch und das muss das irgendwo

hinschreiben.

Und damit solche dynamischen Sachen gehen, gibt es halt dieses, damit quasi irgendwie

der Web-Server mit einem Skript kommunizieren kann, dass man halt irgendwie diesen Kram,

liest und wegschreibt, gibt es halt das Common-Gateway-Interface und das hat das dann so gemacht, es hat dann halt das Skript gestartet,

also weggeforkt und dann irgendwie da per Umgebungsvariablen irgendwie die Daten übertragen.

Das geht, aber es ist halt furchtbar langsam und alles nicht so richtig schön.

Aber so war das damals.

Und da, ich erinnere mich auch, dass man da durchaus Python-Skripte, also meistens hat man Perl verwendet,

aber das ging auch mit Python schon, hatte halt so ein bisschen das Problem, dass die meisten Hoster irgendwie kein Python-Instant haben.

Und deswegen man keine Python-Skripte als CGI-Skripte irgendwie da angeben konnte, aber...

Selbst musste man selber hosten, wenn man Python...

Ja, ja, genau, genau. Insofern war das halt nicht so populär.

Ja, die ganzen anderen Geschichten, das kam alles viel, viel, viel später.

Was war denn so das erste Framework, was so mit hochkam, wo man die ersten Seiten vernünftig mit...

Das gab es für Python, gab es da eigentlich fast nichts.

Also es gab, also da gab es eigentlich nur PHP, also da gab es ModPython.

PHP für den Apache.

Es gab auch einen ModPython, aber das war ziemlich furchtbar, das habe ich mal versucht zu verwenden,

oder ich habe es sogar eine ganze Zeit lang verwendet, aber das war alles ziemlich scheußlich.

Hatte MemoryLeaks, war alles irgendwie ätzend, da waren so komische Sachen passiert.

Also MemoryLeaks heißt dann, der Server stellt ab, wenn den Leute benutzen einfach, wenn die Leute auf dem Server sind.

Ja, man braucht immer mehr Speicher, man weiß nicht genau warum, und dann irgendwann ist er halt weg,

und dann muss man halt nachgucken, was da schiefgelaufen ist, und das ist nicht so schön.

Das ModPython war auch nicht so toll, aber das hat halt so schon irgendwie ganz gut funktioniert.

Ja, das war so die, auch die Anfang der Nullerjahre war so die große Zeit des sogenannten LAMP-Stacks,

so Linux, Apache, MySQL.

PHP?

PHP, genau.

Und das hat so halbwegs funktioniert.

Und ja, Python haben zwar Leute auch quasi als Web-Anwendung verwendet, aber dann immer,

ach doch jetzt, das Erste, was Leute tatsächlich da in Python gebaut haben,

war Soap.

Soap.

Ja, oder Soapy, ich weiß gar nicht genau, wie man das ausspricht.

Da gibt es das noch.

Das gibt es bis heute, und das ist bis heute irgendwie eine ganz tolle Community, irgendwie.

Und da gab es dann auch so ein Content-Management-System, oder irgendwie so ein Ding, was drauf aufgesetzt hat,

das nannte sich Plone.

Also daran erinnere ich mich auch, und das muss irgendwie 2004 gewesen sein,

als ich das zum ersten Mal ausprobiert habe.

Das war alles sehr nett, es war nur furchtbar langsam, aber ansonsten war es alles sehr schick.

Und ich glaube, das waren so die Ersten, die so irgendwie komplexere Web-Anwendungen in Python möglich gemacht haben.

Wie gesagt, manche Leute benutzen das bis heute.

Dieses Projekt hat ein großes Problem mit dem Umstieg von Python 2 auf Python 3.

Ich glaube, da ist noch eine ganze Menge Code nicht umgestellt.

Und ja, jetzt am 1. Januar 2020 läuft ja irgendwie der Support für Python 2 um.

Der ist ja weit, der hat ja noch Zeit.

Ja, das ist nicht mehr so wirklich viel Zeit.

Und keine Ahnung.

Also vielleicht haben sie das auch mittlerweile geschafft, dass sie da umgestiegen sind.

Aber ja, das ist ein bisschen blöd für dieses Projekt.

Ja, aber das waren so die Ersten, genau.

Und dann kam halt näher dazu, als es eine standardisierte, schöne Schnittstelle gab.

Also es gab dann diverse Schnittstellen, die auch besser funktioniert haben als CGI.

Es gab FastCGI.

FastCGI?

Ja, genau.

Das war schneller.

Das war schneller, da musste der Server das Skript nicht forken,

sondern da waren da schon so ein paar Skripte gepreforkt.

Dann konnte man das irgendwie, dann wurden die Daten da halt irgendwie per Interprozesskommunikation irgendwie hingeschoben.

Und das war alles deutlich besser.

Das ging halt dann relativ schnell.

Aber es war auch alles noch ziemlich hässlich.

Und es gibt dann, ich weiß nicht, wann das passiert ist.

Das müsste dann so Mitte der Jahrhundert gewesen sein.

Seitdem gibt es halt Whiskey sozusagen als Schnittstelle zwischen Webserver und Applikation.

Also sich das so halbwegs standardisiert hat.

Hört sich nach etwas ziemlich Holzigem zu trinken.

Ja, also wird aber W-S-G-I geschrieben.

Es wird nur lecker ausgesprochen.

Es ist nicht so lecker, wenn man es sich dann tatsächlich anguckt.

Aber genau.

Und damit ist dann eigentlich auch schon die große Zeit von Apache als Webserver irgendwie so ein bisschen vorbei.

Da tauchen dann plötzlich so andere Server auf, die man halt als Applikationsserver häufig verwendet.

Beziehungsweise man trennt dann eigentlich zwischen Applikationsservern und Web-Servern.

Wie den Servern, die halt statisch verheizt nach außen ausliefern.

Oder die so ein bisschen Reverse-Proxy halt vor den Applikationsservern sind.

Da nimmt man meistens auch nicht Apache, sondern dann sowas wie Nginx.

Oder am Anfang gab es dann LightHTTPD und so.

Und heute vielleicht, für heute nimmt man dann irgendwie sowas wie, na, wie heißt der noch?

Caddy.

Ein Google-geschriebener Webserver, der sich schön auch mit Let's Encrypt irgendwie verbindet.

Und dann hat man halt irgendwie ordentliches SSL nach draußen, irgendwie automatisch.

Man muss da nicht irgendwie, also bei Nginx, also ich habe mich dann beschäftigt, Nginx so weit zu kriegen,

dass es halt irgendwie beim Test von SSL-Labs irgendwie überall grün und okay ist.

Das hat mich irgendwie so zwei Tage gekostet und war irgendwie echt aufwendig.

Und bei Caddy geht das einfach so.

Das ist schon super.

Also den verwende ich jetzt mittlerweile auch meistens vor den Applikationsservern.

Applikationsserver sind sowas wie Junicorn, den verwende ich meistens.

Oder MewsGI oder UwesGI heißt ein anderer.

Oder Werkzeug oder da gibt es einige, die man halt verwenden kann.

Und die sind sozusagen dafür zuständig quasi, dass da drin die Applikation läuft.

Und die Requests, die halt sozusagen nur von der Applikation beantwortet werden können,

die gehen halt dann an diesen Server.

Und ja, die rufen dann halt eben quasi die Applikation mit der entsprechenden API auf.

Also ich wollte jetzt gar nicht unterbrechen.

Das finde ich auch super interessant.

Ich glaube...

Vielleicht sogar nach eigener Web-Folge.

Wir sind ja heute, das wollte ich nicht vergessen.

Ich hoffe, die Anfänger sind jetzt nicht alle schon ausgestiegen.

In der Anfänger-Folge.

Ja, ja, ja.

Da müssen wir noch ein bisschen mehr eingehen darauf, welche Funktionen man mit Python vielleicht noch machen kann.

Genau.

Also wir haben jetzt vielleicht einen kleinen Einstieg schon mal euch gegeben,

was es so an coolen Möglichkeiten heute gibt mit Python und Web-Frameworks.

Was machen wir noch?

Genau, das ist heute auch ein wichtiger Teil.

Glue ist auch noch immer ein wichtiger Teil.

Ich habe jetzt letztens...

Also...

Um vielleicht kurz Werbung zu machen für einen anderen, für einen englischsprachigen Python-Podcast.

Das war Talk Python to Me, glaube ich.

Doch, ja.

Talk Python to Me.

In der letzten Folge, da ging es um Python 3 bei Facebook.

Und da erzählt jemand, der halt Python bei Facebook irgendwie macht,

dass die ganzen Backend-Systeme, die halt irgendwelche Services machen

oder irgendwie Sachen hoch runterfahren, Sachen deployen,

das Ganze quasi Facebook...

Management, Zeugs, das ist halt alles Python.

Also Frontend ist zwar PHP, aber alles, was sozusagen Services miteinander verbindet

oder halt irgendwie interne Geschichten macht, das ist halt bei Facebook alles in Python.

Also natürlich auch YouTube ist in Python.

Ja, genau.

YouTube ist so ein bekannter...

NASA macht viele Sachen mit Python, habe ich gehört.

NASA, ja.

Wollte ich Disney-Filme produzieren und...

Ja, Pinterest auch ist, glaube ich...

Ich weiß nicht genau, ob die...

Die waren sogar Django irgendwie.

Aber auch halt Python hauptsächlich.

Instagram ist komplett Python eigentlich von der Web-Applikation her.

Also ja, es gibt auch durchaus im Frontend einige, die da Python verwenden.

Aber es ist halt im Grunde überall.

Und ja, also dieses Gluding ist auch immer noch eine sehr, sehr wichtige Geschichte.

Aber dann gibt es halt einen neuen Bereich seit einigen Jahren, der halt auch sehr, sehr populär geworden ist.

Das ist halt so ganze Data Science.

Machine Learning-Gebiet.

Daten, diese Sensor-Daten-Erfassung.

Ja, Scientific Computing, dieser ganze Bereich.

Also das, was man früher in so einem Matlab gemacht hat, würde ich sagen.

Ja, oder Mathematiker auch.

Mathematiker hat ja dieses schöne Konzept entwickelt von diesen Notebooks.

Also das kennt man vielleicht, wenn man jetzt im wissenschaftlichen Bereich ein bisschen unterwegs ist.

Weil es gibt so Labortagebücher oder so, wo man aufschreibt, was man irgendwie tut und so.

Also Python, die Jupyter-Notebooks.

Genau, die gibt es in Python.

Und bei Mathematik hatte das tatsächlich zuerst sozusagen dieses Feature, dass man halt solche Notebooks halt dann ausführen kann.

Und dann halt nachvollziehen kann, was da passiert ist, wenn man zu einem bestimmten Ergebnis gekommen ist.

Sehr, sehr gute Idee halt.

Hat sich nie so richtig durchgesetzt, weil Mathematiker ist halt proprietär und teuer.

Und ist auch eine...

Sehr exklusive Community irgendwie.

Und hat irgendwie nie so richtig abgehoben.

Obwohl es eigentlich schon eine sehr schicke Idee war.

Und dann wurde die halt aufgegriffen von den Leuten, die irgendwie so einen Interpreter...

Oder man nennt das irgendwie so...

Rappel...

Weiß gar nicht, wofür diese Abkürzung...

Also diese Shell, die man bekommt, wenn man jetzt Python eingibt.

Du meinst quasi iPython jetzt in dem Fall?

Genau, iPython.

Ja, ja.

Die haben halt sozusagen das da mit reingebaut.

Und das nennt sich dann iPython Notebook.

Also iPython hätte schon den ganzen Teil der Funktion, die man dafür braucht, wenn man sowas implementieren will.

Und iPython Notebook hat dann halt quasi sozusagen die Ideen von diesen Mathematiker-Notebooks irgendwie aufgegriffen.

Und ja, das war ein toller Erfolg.

Man hat das dann auch für andere Sprachen gemacht.

Für R und für Julia.

Und dann war irgendwie klar, dass iPython Notebook ein blöder Name dafür ist.

Weil wenn es halt nicht mehr Python ist, sondern auch andere Seelen, dann wurde das halt unbedingt in Jupiter.

Wobei das halt nicht

wie der Planet geschrieben wird, sondern mit PY halt wie für Python, weil es Julia, Python, R

quasi, also die drei Sprachen, die da halt hauptsächlich irgendwie

verwendet werden. Das sieht ja ganz schick aus, habe ich tatsächlich auch schon ein paar Mal gesehen, das kann man

tolle Sachen mitmachen und auch live den Code direkt testen, ausführen, was man damit macht. Genau, genau, das ist halt

super praktisch, das ist natürlich jetzt schwer, das zu umschreiben, jemanden, der

das nicht kennt, quasi, warum das toll ist,

es ist halt nur so, gerade bei so... Naja, stellt euch vor, ihr könnt ein Buch lesen

und habt ja irgendeine statistische Tabelle, die ihr anguckt und ihr könnt live da

die Daten eintragen, ändern und auch im Schaubild verändert sich direkt mit den neuen

Datensätzen das, was ihr da braucht, was ihr programmiert habt, der Algorithmus, um

das darzustellen, könnt ihr direkt live sehen, was da passiert. Ja, das ist eine der schönen

Geschichten, aber was für mich vor allen Dingen, also ich mache auch viel

Data Science Geschichten, dass das für mich sozusagen das

Top

Feature ist, ist halt irgendwie, so viele der Schritte brauchen eine Menge Zeit, also

wenn man große Datenmengen hat oder so, kann es sein, dass manchmal, wenn man irgendwas macht,

dauert das halt eine Stunde, sozusagen, und dann hat man ein Ergebnis,

irgendeine Berechnung, genau, die man macht, und man trainiert irgendein Modell

oder so, und das rechnet dann halt irgendwie so eine Stunde vor sich hin, und wenn man das jetzt alles in einem

Skript hat, so wie man das normalerweise hat, dann hat man irgendwie so, okay, man erzeugt dieses Modell, dann

macht man da irgendwelche Evaluationen drauf, dann visualisiert man das Ganze, dann macht man da

irgendwelche Tests oder einen möglichen Tragen.

Die ganze Arbeitsschrittkette durchgehen, bis man wieder an dem Punkt ist, den man gerade geändert hat.

Genau, man kann das natürlich dann irgendwie schlau cachen, das habe ich früher dann so gemacht,

da habe ich dann irgendwie Dekoratoren benutzt, die dann halt den Kram immer

irgendwo hingeschrieben haben in ein Verzeichnis, und dann sozusagen immer wieder

nur die Arrays, die dabei entstehen, halt wieder zurück, aber das ist halt

alles nicht so, also das kann man machen, aber diesen Aufwand treibt man auch nur

dann, wenn man sich sicher ist, dass man das wirklich braucht und dann verändern will,

und jetzt möchte man halt am Schluss dieser Kette, die halt irgendwas erzeugt, irgendwie eine Funktion

schreiben, die irgendwas mit den Daten macht, und dann baut man da einen blöden Fehler rein oder so,

und das passiert einem tatsächlich, wenn man, wenn man, wenn man das jetzt so, wie ich das auch

früher gemacht habe, passiert einem das relativ häufig, dass man dann halt den Fall hat, dass

irgendwie, es geht irgendwas schief, man sieht einen Trace weg und denkt sich schon so, oh nein,

was für ein blöder Fehler, und das Ergebnis von irgendwie einer Stundeberechnung oder so ist weg,

und man muss halt im Grunde nochmal eine Stunde warten, also selbst wenn man nur ein paar Minuten

warten muss, ist es halt voll blöd, weil es diesen, man ändert irgendwas, probiert es aus, Zyklus

aus, wenn, wenn, wenn, wenn da viel Latenz drin ist, dann wird man sehr langsam, und dieses Problem

löst Jupyter eigentlich, lösen die Jupyter-Notebooks komplett, weil da ist es halt so, dass man jede

Zelle getrennt ausführen kann, und wenn man jetzt eine Funktion geschrieben hat, die einen Fehler

enthält, und führt die halt aus auf den Daten, die man jetzt da irgendwie eine Stunde lang berechnet

hat, und es geht schief, dann ändert man die Funktion, führt sie nochmal aus, und alles ist

gut, weil, und das Ergebnis ist halt nicht weg, und das ist halt, das ist halt super.

Wenn man sowas arbeiten möchte, ist das, glaube ich, genau, und das, das, das macht einen halt viel, viel schneller,

und das ist, das ist halt total toll.

Also ist das auch für Anfänger sehr gut geeignet, würdest du sagen, auch zu lernen, der Sprache, ja?

Ja, ja, weil es, weil es halt so schön interaktiv ist, also es ist, man kann einfach eine ganze Menge ausprobieren,

ohne, dass man jetzt irgendwie

Editor lernen muss, und ohne, dass man irgendwie quasi wissen muss,

also das, ja, man kann halt einfach direkt was ausprobieren, wenn es halt schief geht, dann ändert man

die Zelle, und führt sie nochmal aus, und dann ist es okay. Ja, das bringt uns, glaube ich, direkt zu unseren Anfänger-Tipps,

ich glaube, das ist ja gar nicht so schlecht, also wenn ihr Fragen habt, natürlich direkt irgendwie an hallo

at pythonpodcast.de, einfach

stellen, dann erklären wir euch auch alles, was ihr gerade vielleicht noch nicht verstanden habt, oder was euch ein bisschen zu schnell

ging. Vielleicht mit ein paar Tipps anfangen, ich glaube, also

ganz wichtig ist natürlich die offizielle Dokumentation, Aussage des Food zum Lesen, ich glaube,

da findet man so die meisten Erklärungen für die Standardbibliothek, wie das alles so funktioniert,

außer von den Tutorials, die es jetzt gibt. Ich habe zum Beispiel mit

Python the Hard Way angefangen, und das Buch von Seth Torr gelesen, war ein ganz guter Einstieg,

ja, wenn man sich da so durcharbeitet, kommt man relativ tief in die Materie rein,

es gibt noch Automated

Boarding Stuff with Python,

geht auch auf deutschem Buch zu, das kostet dann leider Geld,

ansonsten ist das ein kostenloses Tutorial,

ja, die ganzen Tutorials gibt es sonst bei uns nicht,

auf Datacamp, Udemy, Udacity,

unzählige kostenlose,

ja, du hast ja gerade gesagt, anfangen

vielleicht mit Jupyter Notebook oder auch einem einfachen

Text-Title, also ich kann jetzt nicht empfehlen,

direkt mit einer großen Entwicklungsumgebung zu starten,

das hält dann erstmal so ein bisschen auf,

dann gibt es ja dann irgendwann später

ganz viele tolle Editoren,

PyCharm, Idle, PowerScore,

BI, Atom, MX,

was benutzt du?

BI,

ja, das ist,

ich benutze aber auch PyCharm zum Beispiel

mittlerweile, weil mich nervt, dass es halt

doch relativ langsam ist, und

ja, das ist

immer bei diesen,

eigentlich ist das schön, also diese ganzen IntelliJ

EDEs,

das ist alles schon sehr nett gemacht, die können auch

sehr viel, aber

die reagieren nicht so instantan,

also es ist immer, wenn man irgendwo draufdrückt oder so, dann

muss man erst mal, es ist so,

zu langsam, es ist einfach zu langsam,

es ist nicht, es ist nicht so,

es fühlt sich halt nicht so

snappy irgendwie ordentlich

an, wie sich halt so ein Profi-Werkzeug anfühlen

sollte, sondern es fühlt sich halt immer so an

wie, keine Ahnung,

wie diese, weiß ich nicht,

also ich meine, gut, das ist ein böser Vergleich, aber wenn man

so einen Fahrkartenautomat bei der Bahn steht und

drückt da drauf, und dann

passiert einfach nichts, und dann drückt man

nochmal drauf, aber dann, und dann macht es irgendwie so

Kennt ihr das, wenn ihr euch gerade so einen

Toko-Riegel aus dem Automaten ziehen wollt, und dann bleibt der irgendwo

ja oben hängen? Ja, und das ist

halt, das ist halt schon sehr,

so ein bisschen nervtötend, und deswegen benutze

ich das eigentlich nicht so gern, obwohl manche Features

halt durchaus so nett sind, dass ich es

halt auch immer wieder verwende, aber

wenn ich

BI verwenden kann, dann verwende ich eigentlich, also

BIM, da hat sich auch einiges getan.

Wie, hast du denn Python gelernt?

Hast du da irgendwie

Tutorials gemacht, oder warst du da direkt drin?

War das so basics, dass man alles selber weigen musste?

Ja, aber es gab nicht

so viele Bücher,

damals, es gab ein paar,

die waren aber auch alle nicht so wirklich hilfreich, also

doch, es gab ein Buch, das war hilfreich, ich weiß

aber nicht, ob das immer noch

eine gute Empfehlung ist, es war das Python-Cookbook,

das war ganz gut,

ansonsten

waren die meisten Bücher nicht so toll,

und ja,

ich, wie habe ich es gelernt, also

ich hatte halt das Glück, dass

ich da neben ihm gesessen hatte, der das schon konnte,

und wenn mir das dann gesagt hat,

ja, das war etwas lukriöse,

das war relativ praktisch.

Ja, das kann ich auch tatsächlich auch empfehlen, also versucht nicht nur

im stillen Kämmerlein zu sitzen und euch selber

durch den Kram zu quälen, also es geht bedeutend

schneller, und ihr kommt auch bedeutend schneller weiter, wenn ihr

tatsächlich jemanden habt, der euch so ein bisschen zeigt, wie das

Ganze geht. Danke, Jochen!

Deswegen sitze ich ja hier und stelle dir die ganzen

doofen Fragen.

Ja, also genau, man könnte auch

zu Meetups durchaus

gehen, sich da mit Leuten austauschen, hilft es.

Die tägliche

Arbeit muss man natürlich dann trotzdem machen,

aber ich glaube, mittlerweile kommt man da ganz gut

angeleitet auch in die ersten eigenen Projekte so rein.

Ja.

Wie funktioniert Python eigentlich?

Was ist das Ding?

Wo kann man das machen? Also ich habe jetzt hier zum Beispiel

auf meinem großen Zettel stehen,

Simple Prototyping kann man machen,

und recht umfangreiche Bibliotheken.

Ja, also

Python selbst ist halt eine...

Einfach? Ja. Ist das einfach?

Es ist ziemlich, ja,

es verbinden halt zwei Dinge, die sich eigentlich ein bisschen widersprechen.

Es ist halt sehr einfach, und es ist halt

trotzdem sehr mächtig,

das macht es halt sehr schön. Auf der anderen Seite

bedeutet das halt, dass es nicht so einfach ist, das irgendwie

in Binärcode zu kompilieren oder so.

Das ist halt mit einer Sprache, die halt

wesentlich einfacher sozusagen ist,

ist das halt simpler. Also wenn man

C nimmt, C kann man, so ein mehr oder weniger

Macro-Assembler, da kann man das dafür in den Compiler zuschreiben.

Warum muss man denn überhaupt etwas in Binärcode kompilieren?

Ja, wenn es

ein Computer direkt ausführen können soll,

dann muss das irgendwie Maschinencode sein.

Ah, Binärcode, Nullen und Einsen.

Genau, genau, genau.

Wenn das so

etwas ist, dann kann es halt direkt

ausgeführt werden. Also die meisten Programme,

die man so kennt, sind das halt auch.

So wie früher, wenn ich mir das so vorstelle, da hat man diese ganzen

großen Rechner gehabt, die Lochkarten gelesen

haben für Nullen und Einsen. Das braucht der Computer

auch heute noch, damit er versteht, was er da überhaupt machen muss.

Ja, genau. Und dann läuft halt

dieses Programm direkt irgendwie

auf dem Prozessor und

ja, aber das geht halt,

das ist halt etwas, was dann nicht mehr geht mit Python,

weil für Python Compiler zu schreiben

ist halt dann nicht mehr so einfach.

Oder eigentlich immer so ziemlich unmöglich,

weil das ist halt alles dynamisch und zur Laufzeit

kann sich eine Menge ändern. Das geht halt nicht

so richtig. Das ist halt in der

Preis, die man zahlt, dass man es nicht mehr kompilieren kann.

Es wird dann halt interpretiert.

Also es wird schon so ein bisschen

verändert. Es wird in einen Bytecode

verwandelt und der Bytecode wird dann interpretiert

von einer virtuellen Maschine. Das sind dann die

PyC-Dateien, die man findet, nachdem man irgendwas

gelaufen hat. Genau, genau.

Also C ist das, was dann das Ganze

benutzt, um das dann für die Maschine

schreiblesbar zu machen?

Ja, aber für die Maschine ist das nicht lesbar.

Man braucht immer noch den Python-Interpreter,

der das dann ausführen kann.

Also, ja, genau.

Der Python-Interpreter ist halt genau diese virtuelle Maschine

und der kann das dann halt ausführen.

Und

ja, das hat dann auch so einige andere Nachteile.

Das macht es halt auch schwer, Sachen zu installieren

oder so, weil man kann

jetzt nicht einfach irgendwo

ein Binary runterladen.

Ich glaube, es gibt da PIP.

Ja, genau. Dann muss man eben zu so

Paketmanagern greifen, die

das hat, mit denen man irgendwelche Dinge installieren kann.

Aber man kann halt jetzt nicht irgendwie auf dem USB-Stick

jemandem irgendwie

Python-Programm geben und der

startet das dann halt. Das geht halt.

Wenn ich das richtig verstanden habe, PIP ist dann dieser Paketmanager, der

über die Seite PyPy oder wie es ist, über den

Server von dem läuft und dann da

Pakete installiert, die andere dort bereitgestellt

haben, die schon damit veröffentlicht

sind. Das heißt, wenn ihr eure eigenen Pakete

baut, müsst ihr die entweder so veröffentlichen

oder tatsächlich

exzellente Bibliotheken nehmen, um einen Installer zu bauen

oder sowas. Genau, das gibt es auch.

Es gibt diverse Geschichten, die das

dann halt versuchen, irgendwie in Bein und Riech zu packen.

Und das funktioniert auch manchmal.

Kannst du kurz zwei, drei Installer

nennen, die man versucht für verschiedene Systeme? Einmal

vielleicht für Linux, für OS oder für Windows oder so?

Ich benutze das selber nie.

Py2Exe für Windows

gibt es da irgendwie. Bei Linux braucht man das, glaube ich,

nicht groß.

Baust du ein Paket, machst du ein Shell-Install-Setup?

Unterlegung gibt es auch in so einem Ding, was

quasi den

Interpreter mit reinpackt in Binary.

Kann sein, dass es

ein Installer ist.

Wenn man da so ein bisschen

aufpasst, dann kriegt man

den Interpreter relativ klein.

Also wenn man es einfach naiv macht, dann

kann es sein, dass es so 15 MB

sind oder 10.

Man kriegt es auf zwei, drei runter,

wenn man sich da ein bisschen Mühe gibt.

Und dann ist es eigentlich, ich meine, heutzutage ist das

sowieso alles nicht mehr so wild.

Es gibt natürlich Leute, die sagen würden,

wenn ich das mit C mache und dann gut

und nicht gegen die

Libc-Linke oder gegen die

G-Libc, sondern halt irgendwie

so eine Diät-Libc oder irgendwas

anderes kleines.

Das sind die Standard-Bibliotheken, die C so

bereitstellt für die Befehle, die dann das Ganze

größer machen, wenn man das kompiliert, oder?

Genau, da ist ein bisschen Standard-Bibliothek dabei, aber eigentlich,

wofür die da sind, ist die Kommunikation mit dem

Kernel, mit dem Betriebssystem.

Und das kann man natürlich auch

beliebig komplex gestalten, aber wenn man halt

nur die ganz simpelsten Dinge haben

will,

dann muss das nicht so groß sein, weil das Problem ist,

es muss halt irgendwie dagegen gelinkt sein,

damit irgendwie der Prozess überhaupt

irgendwas machen kann, wie Eingabe, Ausgabe und so.

Aber wenn man das

schlau macht, dann kriegt man das halt auf, weiß ich nicht,

ein paar hundert Byte oder so runter.

Und das ist natürlich was ganz anderes, als wenn ich jetzt irgendwie

megabyteweise Zeugs...

Das könnte auch Mikrocontroller packen. Ich glaube, man kriegt das sogar in so einen Bootsektor rein.

Wie viel hat so ein Bootsektor? 512 Bytes?

Keine Ahnung, ja.

Also natürlich

ist es nicht so klein, wie es gehen

könnte, wenn man das wirklich

drauf anlegt.

Und das wird auch nie gehen

mit Python so richtig, aber

also heutzutage sind ja auch ein paar Megabyte

eigentlich nicht mehr wirklich

viel.

Früher war das auch sehr schlimm,

heute...

Genau, und

daher ist das eigentlich auch alles nicht mehr so wild. Aber man muss auch

sagen, dass dieses Thema so ein bisschen vernachlässigt wurde,

gerade auf Windows und so,

da kann man ja auch nicht davon ausgehen,

also bei den meisten Linux-Systemen wird halt einfach ein Python-Interpreter

vorinstalliert sein, vielleicht ein uralter, aber

immerhin.

Aber bei Windows ist halt Python nicht

vorinstalliert und wenn man irgendjemandem

ein Python-Script schickt oder so, kann der halt

nichts damit anfangen. Das ist ein bisschen

ein Problem. Das ist halt auch ein bisschen ein Preis,

den man dann halt zahlt, dafür, dass es

halt einfach ist, aber trotzdem

sehr mächtig.

Und ja, also...

Die Beine richtig kriegt ihr natürlich trotzdem

auf der Python-Home-Stage direkt,

für die jeweiligen Systeme und wenn das...

Der Python-Interpreter selber ist natürlich wieder

quasi so ein... Also einige Leute

empfehlen auch Anaconda, das ist irgendwie so ein Paket, womit man ganz viel

tolle Datensachen machen kann, wo es

vorinstalliert ist. Also ich persönlich hatte da

nicht so die besten Erfahrungen mit, das war einmal sehr

verwurschtelt mit den Paketen, dann lief

immer was nicht, wenn es irgendwie ein Update gab von der

neuesten Python-Version. Die haben auch einen eigenen

Paketmanager, Anaconda irgendwie und deswegen

würde ich das für Anfänger jetzt nicht unbedingt sofort empfehlen,

obwohl viele das machen, aber das könnt ihr

ja selber schauen. Ja, Anaconda ist ein bisschen

verwirrend, weil also eben

es ist eben kein Paketmanager und auch

nicht... Also Anaconda ist eine Distribution

sozusagen von Paketen,

aber

...

Anaconda ist der Paketmanager und es gibt

auch noch ganz viele andere Pakete,

die jetzt nicht in der Anaconda-Distribution

drin sind. Und

das ist so ein bisschen... Eigentlich ist das

alles ein bisschen furchtbar. Man muss sagen, dass

schön wäre ja, sozusagen in einer idealen

Welt hätte man das ja gerne, dass man

sozusagen einen Paketmanager für alles verwendet.

Also es gibt auch so ein bisschen die

Utopie, wird so ein bisschen

gelebt bei

NixOS.

Versuchen Leute das tatsächlich noch umzusetzen

oder eigentlich waren auch die Linux-Distributionen mal so

quasi gedacht, dass man halt

hat einen Paketmanager, mit dem installiert man halt

irgendwie alles, was man irgendwie haben möchte.

Und

das geht ja auch jetzt noch, wenn man jetzt

einen Debian hat beispielsweise, dann kann man auch

einen NumPy oder so, was ja

quasi ein Modul ist

für Scientific Computing, ein Modul für

Python, kann man durchaus per

Debian-Paket installieren, also über die Distribution.

Es ist halt nur so, dass man das nicht tun

sollte, weil dann bekommt man eine Version, die nicht optimiert ist,

wo der Maintainer... Also ich meine, vielleicht

ist es auch gut, ich weiß keine Ahnung,

aber die Wahrscheinlichkeit ist hoch,

dass es eben dann nicht schnell ist.

Weil es ist halt nicht gegen MKL

diese Mathe-Bibliothek von Intel

gelingt beim Kompilieren.

Also es ist halt tricky, das zu kompilieren,

da ist viel Core-Transworks dabei.

Das ist alles nicht so einfach und

überfordert möglicherweise

halt den Debian-Maintainer auch so ein bisschen.

Also du würdest auch immer

alle Pakete über PIP installieren?

Naja, nee, ich würde sagen, es kommt drauf an.

Leider haben wir nicht...

Am schönsten wäre es, wir hätten einen Paketmanager für alles,

also zum Beispiel PIP oder deinen

Distributionsmanager.

Oder weiß nicht, was es dabei

bei YAMM für

Red Hat gibt oder was da noch war.

DNF ist mittlerweile, glaube ich, auch bei Red Hat, also zumindest bei Fedora.

Ja.

Ich bin da auch gar nicht mehr so am Laufen, aber

genau.

Wenn man einen Paketmanager hätte, mit dem man alles installiert

und dann sich relativ sicher

sein könnte, dass das halt irgendwie funktioniert, das wäre

schön. Aber

es hat sich jetzt aber eher so entwickelt, dass

jede Programmiersprache so ein bisschen,

ihren eigenen Paketmanager mitbringt.

Also bei Python ist es halt

erst mal PIP.

So wie bei Ruby ist das dann halt...

sind das diese Ruby-Gems.

Bei Perl ist es Cpan bzw.

ich weiß gar nicht, was jetzt das

Ding ist, mit dem man die Dinger installiert.

Dann bei, weiß ich nicht,

JavaScript ist es halt NPM oder YAM

oder was auch immer man da gerade verwendet.

Und

das ist dann natürlich nicht mehr so toll, weil das

Problem ist, dass wenn man die jetzt benutzt, die Sachen

wenn man die jetzt quasi einfach so

ins Notfallsystem installiert, dann überschreiben

die natürlich Sachen, die die Disponition da reingeschreibt hat.

Die überschreiben sich doch auch gegenseitig in verschiedenen...

Die überschreiben sich gegenseitig. Alles nicht so schön.

Da hat niemand drauf aufgepasst, dass die Sachen auch alle miteinander

klarkommen. Das heißt, es können die komischsten Dinge passieren.

Das ist halt nicht so toll.

Was macht man denn da? Dafür gibt's ja eine Lösung.

Ja, dafür versucht man das dann irgendwie zu isolieren und installiert halt Dinge nur in Environments.

Also in virtuellen Entwicklungen.

In virtuellen Umgebungen, genau.

Oder für seinen einen User. Also zum Beispiel "pip install paketname --user"

Ja.

Würde halt das für den aktuellen Nutzer nur installieren.

Genau, das kann man auch machen.

Und das sind halt so bisschen krütige Lösungen für dieses Problem.

Aber leider ist es sogar noch schlimmer.

Es ist jetzt nicht nur so, dass jeder Programmiersparer einen eigenen

Paketmanager hat, sondern es sieht so ein bisschen, also jedenfalls bei Python

ist es leider so, dass auch jede Community hat sozusagen ihren eigenen Paketmanager nochmal.

Die ganze Web-Community verwendet eigentlich überwiegend pip, während die ganze Data-Science-Community

überwiegend conda verwendet. Und wenn man sagen muss, conda ist ein bisschen mächtiger als pip.

Man kann damit nicht nur Python-Pakete installieren, sondern halt auch diverse andere Binär-Pakete.

Und manchmal muss man das halt dummerweise auch, weil viele der Sachen, die man da verwendet, sind halt

Fortran-Bibliotheken oder irgendwelche C-Bibliotheken oder C++.

Warum verwendet man denn Fortran oder C- oder C++-Bibliotheken in Python?

Ja, genau. Das ist halt auch, weil wenn man jetzt zum Beispiel Matrizen miteinander multiplizieren will oder so,

dann könnte man das natürlich auch in Python machen, indem man einfach For-Loops ineinander schachtelt.

Also man speichert die Dinger einfach quasi als zweiendimensionale Listen oder so.

Man hat einfach eine Liste von Listen und dann quasi eine Liste von Spalten oder Zeilen.

Moment, NumPy, glaube ich. Geht das so?

Ja, ja, genau. Also man könnte es direkt in Python machen. Dann macht man halt irgendwie so eine Liste von Spalten oder Zeilen.

Ja, ja, genau. Also man könnte es direkt in Python machen. Dann macht man halt irgendwie so eine Liste von Spalten oder Zeilen.

Ja, ja, genau. Also man könnte es direkt in Python machen. Dann macht man halt irgendwie so eine Liste von Spalten oder Zeilen.

Ja, ja, genau. Also man könnte es direkt in Python machen. Dann macht man halt irgendwie so eine dreifach verschachtelte For-Loop und iteriert über die Dinger und rechnet das dann halt aus.

Das kann man machen. Das ist halt dann sehr, sehr langsam.

Wenn man jetzt so eine Bibliothek benutzt wie NumPy oder so, die haben dann halt einen speziellen Array-Type sozusagen.

Und wenn man da jetzt sagt, multiplizieren wir mal A und B,

dann nutzt man dann halt einen speziellen Array-Type sozusagen. Und wenn man da jetzt sagt, multiplizieren wir mal A und B,

dann nutzt man dann halt einen speziellen Array-Type sozusagen. Und wenn man da jetzt sagt, multiplizieren wir mal A und B,

dann nutzt man dann halt einen speziellen Array-Type sozusagen. Und wenn man da jetzt sagt, multiplizieren wir mal A und B,

Und Nampai unten drunter halt quasi, weiß ich jetzt gar nicht, was man da möchte.

Ich würde mir jetzt gerade so auszumalen, wie das dann so aussieht in dem Schaubild, um mir das irgendwie so ein bisschen vorzustellen, warum das jetzt schneller geht.

Also die benutzen drunter einen neuen Motor.

Benutzen drunter optimierte Fortran-Bibliotheken.

Oder ist es, ich weiß gar nicht mal, ob es Fortran ist unbedingt.

Also es ist halt irgendwie, die haben halt damals angefangen mit Blas Lafac Atlas.

Das sind so die Dinger, die da unten drunter liegen.

Und es gibt, glaube ich, irgendwie so eine definierte Schnittstelle für solche, für diese ganzen Operationen.

Und dann sind das irgendwie Implementationen davon.

Und ja.

Nennen wir es Magic.

Genau, Magie.

Also Fortran ist halt irgendwie, als Sprache ist es immer noch deswegen so wichtig, weil da Sachen sich quasi mehr oder weniger automatisch vektorisieren lassen.

Das bedeutet, dass man nicht loopt über Sachen, sondern dass der Prozessor das quasi übernimmt.

Also das ist, also wenn man das einfach an C kommt, dann sollte ich auch eine Loop hinschreiben.

Wäre schon viel schneller als ein Python.

Wahrscheinlich so tausendmal schneller oder so.

Aber selbst das wäre deutlich langsamer als das, was quasi die Bibliotheken, die unter einem Namenpeil liegen, halt machen.

Nee, stimmt.

Genau.

Hat so ein bisschen den Nachteil, dass man halt den Code anders strukturieren muss.

Man kann eben dann keine Vorschleife mehr verwenden, sondern man macht eher solche Sachen, wie man auf den Objekten, die man erzeugt hat,

wie zum Beispiel irgendwelche Arrays oder so, ruft man dann halt irgendwie eine Funktion auf und übergibt denen ein Callback oder so.

Weil Vorschleifen gehen halt nicht mehr.

Das ist ein bisschen komisch, aber ist halt dafür schnell.

Wie ist da so ein Trade-Off?

Kann man sich überlegen, ob man sich das angewöhnt hat, dass man das gerne macht oder ob man sagt, hey, wir nehmen jetzt das ein bisschen in Kauf.

Python ist ja immer als langsam verschrien.

Aber wenn wir die auch schnell bekommen, ja okay, dann machen wir vielleicht mal einen kleinen Umweg.

Genau, genau.

Ja, kommen wir vielleicht noch zu, wenn es um die Mythen geht.

Aber man kann damit auch sehr schnell Dinge tun.

Und dafür muss es halt auch Bibliotheken basieren, die das halt auch schnell machen können.

Und für Scientific Computing und Zeugs ist es halt vortragen oft.

Ja, genau.

Ja, vielleicht nochmal genau zu diesen ganzen Bibliotheken, die man machen kann.

Du hast gesagt, glaube ich, Data Science kann man ganz viel machen und Web kann man ganz viel machen.

Und für diesen Glue, also den Klebstoff zwischen einzelnen Modulen, kann man ganz viel machen.

Und so zum Skripten.

Fällt dir noch irgendwas ein?

Oh, ja, ja, ja.

Was ich ein bisschen vernachlässige.

Genau, auch ein Bereich, der momentan sehr interessant wird.

So Home Automation Zeugs, Smart Home.

Raspberry Pi, der macht ja ganz...

Ja, genau.

Raspberry Pi wird da oft verwendet.

Und überhaupt Raspberry Pi und Python haben viele schöne Anwendungen.

Da kann man viel drauf machen.

Home Automation, du hast hier, glaube ich, ganz viele schöne Sachen mit.

Ja, ich habe auch einen Raspberry Pi irgendwo im Schrank stehen, der zum Beispiel Temperaturen ausliest.

Ich habe so ein DVB-T-Modul da dran gesteckt.

Die gibt es jetzt irgendwie günstig, weil es keinen DVB-T-Modul gibt.

Ich wollte gerade sagen, also das ist doch gerade abgeschaltet worden.

Richtig.

Jetzt kommen wir in die Dongle, kriegt man relativ billig.

Und da ist so eine Sache.

Und da ist so eine Antenne dran und dann habe ich hier irgendwie so Sensoren und die funken halt auf den Frequenzen.

Ihre Werte halt so alle paar Sekunden oder so.

Und dann muss man die eigentlich dann nur einsammeln und dann an ein Software, das nennt sich Home Assistant, schicken.

Also das ist ein bisschen komplizierter.

Ja, da macht man auch noch eine eigene Folge für sich.

Genau.

Aber solche Sachen.

Also wenn man zum Beispiel...

Also ich sehe jetzt aber zum Beispiel keine Schläuche in den Pflanzen, die du hier in deinem schönen Wintergarten stehen hast.

Das heißt, das musst du noch selber gießen.

Genau.

Ja, furchtbar.

Da musst du unbedingt automatisiert werden.

Ich weiß noch nicht, wie ich den Wassertransport automatisieren soll.

Das ist ein bisschen gefährlich.

Eine Pumpe irgendwie und ein Eimer einfach.

Ohne Haftpflichtversicherung.

Ja, wäre eine Idee tatsächlich vielleicht.

Ja, genau.

Ja, aber in dem Bereich ist Python halt auch, glaube ich, sehr, sehr stark unterwegs.

Und da gerade, wenn man jetzt...

Also einmal auf der Serverseite sozusagen.

Also das Ding, was diese ganzen smarten, mehr oder weniger smarten Geräte halt sozusagen managt.

Und mit denen da irgendwas macht, irgendwelche Sensordaten ausliest.

Die Seite ist Python.

Aber halt auch die Sensoren selber.

Also man kann zum Beispiel...

Es gibt da so kleine Boards.

Kosten ein paar Dollar.

Und da ist ein Chip drauf mit ein wenig...

Ist nicht so schnell und hat auch wenig Speicher.

Aber da läuft Micro-Python zum Beispiel drauf, sodass man da halt...

Nächste Folge.

Ja, genau.

Das heißt, man kann auch da Python drauflaufen lassen.

Und dann irgendwie Sensordaten.

Damit schon irgendwas machen.

Da muss man erst mal wieder aufpassen, dass wir die Module so nehmen, dass sie möglichst klein werden.

Genau.

Da muss man wieder ein bisschen aufpassen und so.

Aber ja, also in dem Bereich ist Python halt auch sehr, sehr stark vertreten.

Ja, ich glaube, was noch dazukommt vielleicht ist Rapid Prototyping.

Jetzt nochmal als Buzzword reingeschmissen.

Man kann relativ schnell irgendwelche Prototypen bauen von Dingen, die man benutzt.

Sei es jetzt im Web oder bei Daten, die dann auch funktionieren, die kurz sind.

Wenn man jetzt zum Beispiel die Sprachvergleiche...

Ist ja auch sehr einfach.

Deswegen eignet sich das besonders gut.

Ist vielleicht am nächsten am Pseudocode dran, so von dem, was ich so gesehen habe.

Das heißt, man kann relativ einfach die Syntax formulieren und hat direkt ein glaubfähiges Programm,

was wenigstens so grob das tut, was es sollte später.

Ja.

Dazu sozusagen ist noch so einer große Vorteil der Sprache, wo man jetzt von außen draufguckt.

Für den Anfängern oder so.

Ja, vielleicht wäre es ganz interessant, das mal so ein bisschen zu differenzieren gegenüber den anderen Sprachen,

die es halt in den ganzen Bereichen auch gibt.

Ja.

Wo man auch diese ganzen Dinge tun kann.

Also Python ist halt, würde ich sagen, gehört zur Familie der Skript-Sprachen irgendwie.

Also man könnte sagen, es ist sowas ähnliches wie Ruby oder wie Perl oder auch ein bisschen wie JavaScript.

Aber unterscheidet sich halt...

Oder PHP unterscheidet sich von denen aber.

Also wie zum Beispiel JavaScript und PHP, die sind halt dynamisch getypt sozusagen und schwach getypt.

Das heißt, Dinge können ihren Typ ändern oder man weiß nicht, was sie sind sozusagen von Anfang an.

Ja, also Python auch so.

Ist in Python auch so.

Ja.

Aber in Python ist halt streng getypt auch.

Das heißt, es ist dynamisch und streng.

Das heißt, wenn ich jetzt sage, irgendwie eine Zahl plus irgendwie ein String oder so,

dann kriege ich bei Python halt einen Type Error, also...

Einen Typenfehler.

Einen Typenfehler.

Ja, also ich versuche eine Zahl mit einem Wort zu verrechnen.

Genau.

Da haut mir Python halt auf die Finger, während in PHP oder in JavaScript passiert dann halt irgendwas.

Und was passiert denn da?

Ist das Magie?

Oder ist das keine dunkle Magie wahrscheinlich?

Es ist eher dunkel.

Also man weiß nicht so genau, was dann passiert.

Es kommen die komischsten Sachen.

Aber es gibt einen schönen Vortrag für JavaScript.

Das ist mal jemand...

Es ist ein bisschen veraltet, aber hat das mal jemand aufgeschrieben.

Ich glaube, wenn man danach sucht.

So JavaScript Talk und dann Watt, W-A-T, dann findet man das.

Und dann, wo er dann so eben solche Dinge macht wie irgendeine Zahl plus leer Stringen.

Und dann kommen halt die seltsamsten Dinge dabei raus.

Oder selber hüpft und blinkt und...

Ja, am Schluss kommen irgendwelche Zeichenkanten dabei raus und Batman erscheint.

Also es ist halt wirklich...

Man muss aufpassen, dass man da tut.

Ansonsten passieren ganz, ganz furchtbare Dinge.

Klingt so, als könnte man das gut ausnutzen.

Ja.

Und es passieren halt auch regelmäßig wirklich, wirklich schlimme Sachen.

Die Welt geht unter.

Ja, ja.

So ungefähr.

Und das kann bei einem Python halt nicht so leicht passieren.

Das ist schon mal ganz schön.

Also insofern ist es halt in der Welt...

Es ist halt ein schöner...

Also ich finde, was man über Python sagen kann, ist, es macht halt die richtigen Tradeoffs.

Also es ist halt immer...

Es ist halt so eine Sache.

Das hat natürlich auch Vorteile. Man kann Dinge vielleicht abkürzen oder so, wenn man das schwach getypt will, wenn man das nicht so streng überprüft. Man kann das teilweise ausnutzen, um Sachen eleganter zu machen, aber man zahlt halt einen Preis dafür. Und Python hat so die Tendenz, immer diese richtigen Trade-offs zu machen.

In der neuen Version, ich weiß jetzt gar nicht, ob das bei 3.7 kam oder bei irgendeiner 3.6 Version, dann kann man diese Typen jetzt so schön annotieren noch für Funktionen oder für Variablen direkt und sieht dann, dass direkt das beispielsweise in seinem Glinter oder sowas, also das, was den Code unterstreicht, wenn ein Fehler da ist, dass der Typ falsch ist. Also wenn man jetzt Standardtypen eher haben möchte oder feste Typen und keine dynamischen, dass man zumindest weiß, was da stehen sollte, obwohl das Python immer noch versucht zu sprechen.

Ja, aber das Schöne ist halt, das ist halt optional. Man kann das da ranschreiben.

Also klar.

Ja, natürlich. Das ist auch einer der Vorteile, die in so einer Sprache wie Java oder so, die ist halt statisch getypt, also nicht dynamisch. Da kann man hinterher, wenn ich einen Variabler habe, die ändert sich nicht einfach so in einen anderen Typ. Das geht da halt gar nicht.

Und das kann auch nicht sein, dass halt hinterher der Typ erst festgelegt wird zur Laufzeit, sondern das muss halt zur Compile-Zeit sozusagen, wo der Source-Code in Bytecode verwandelt wird, muss das halt feststehen. Eine schöne Geschichte, die man dann halt bauen kann, ist halt Unterstützung in den IDEs.

Also wenn ich halt weiß, sozusagen, dass diese Variable halt den Typ hat, dann kann die IDE mir schon auf die Finger hauen, wenn ich versuche, damit etwas zu machen, was halt nicht geht.

Also das klingt auf jeden Fall nach einem interessanten Trade-off, weil als Anfänger würde ich mir jetzt erstmal so denken, dynamisch klingt ja voll cool, kann das immer was Verschiedenes sein und dann kann ich ganz tolle Sachen mitmachen. Und du sagst jetzt gerade, der Start ist natürlich auch voll toll, weil man kann das irgendwie nicht verwechseln und man bekommt keine Fehler.

Naja, der Nachteil dabei ist halt, da muss man viel mehr schreiben. Was auch nicht so ein Problem ist, wenn man eine IDE verwendet, weil die schreibt das dann für einen so ein bisschen.

Aber man braucht dann halt eine komplizierte IDE, die irgendwie Dinge tut und dann auch nicht mehr so schnell sein kann.

Also man kann damit auch programmieren, so schlimm ist es nicht, aber es ist halt so ein bisschen, ich mag es nicht so, ich mag lieber, man schreibt wenig und schreibt das dann halt aber selber und das Tool, was man dafür verwendet, ist halt schnell, als die IDE schreibt das, aber die ist so ein bisschen laggy und man muss ein bisschen auf die warten.

Ja gut, aber das geht auch. In Python hat man das jetzt halt so nicht, das ist alles dynamisch.

Man kann aber auch Typ-Annotationen jetzt, das ist auch eine sehr neue Geschichte, kann man halt halt dazuschreiben und dann könnte einem die IDE, oder vielleicht PyCharm und so können das möglicherweise auch schon, die kann einem dann dabei helfen und dann auch sagen, wenn irgendwas nicht geht.

Also zum Beispiel in Listen kann man auch verschiedene Datentypen benutzen, es sei denn, man benutzt ja Slump-Arrays, wo das dann auch hier fest ist, aber ja, das ist glaube ich auch ganz interessant, weil wie das halt sein kann, wenn man durch so eine Liste iteriert und man macht irgendeine Multiplikation oder sowas, dann fliegt einem das um die Ohren, weil das der falsche Datentyp ist.

Das ist genau eine dieser Geschichten, wo halt statisch getypte Sprachen große Schwierigkeiten mit haben oder es einem als Programmierer das Leben halt schwer machen, so diese ganzen Containerdatentypen, die sind da halt knifflig oder man kann halt im Grunde immer nur Container haben, die halt dann irgendwie Dinge von einem Typ enthalten, weil man muss ja irgendwie sagen, welchen Typ die Variable hat, die man da reintut und das ist halt, also gut, geht mittlerweile auch, es gibt Generics und sind inzwischen auch in Java angekommen.

Man kann da auch so Sachen machen, aber das ist alles dann nicht mehr so richtig einfach und ein Ding, was man dann halt oft sieht, was Leute dann machen, ist, sie haben halt, naja, also um diese Unzulänglichkeiten, sag ich mal, so könnte man das sehen in der Sprache, zu kompensieren, überlegen sie sich dann halt irgendwie Patterns, wie man bestimmte Probleme, auf die man dann stößt, wenn man nicht mehr einfach quasi beliebige Dinge irgendwie in ein Ding, was halt über Sachen iteriert, packen kann, ja, weil so ein Python-Iterator ist halt, der iteriert halt über Sachen und da kann halt beliebiges Zeug dran sein.

Aber, wenn das halt nicht geht, dann, ja, macht man halt, dann muss man sich halt so Patterns überlegen, wie man Dinge tun kann, ne, und für viele Situationen ist es dann halt, kann man das halt nicht einfach so hinschreiben, was man machen möchte, sondern dann muss man halt, dann gibt's ein ganzes, gibt's ein Gang of Four-Buch, irgendwie, das ist ein ganz bekanntes Buch von, na, wie heißt das, das wird immer ein Gang of Four-Buch genannt.

Ja, das musst du unbedingt auch in die Show noch packen.

Ja, ich glaub, das Ding heißt auch immer Design-Patterns oder so, und das sind halt, ich weiß nicht, wie viele, das sind hundert oder irgendwas in den Dreh, typische Design-Patterns, die man halt jetzt in so statisch getübten Programmi-Sprachen vor allen Dingen verwenden kann, wenn einem solche Probleme halt plagen, wie man damit umgeht, und die das dann halt hübsch lösen, sozusagen.

Und wenn man dieses Buch durchgeht und sich dann überlegt, wie würde ich das in Python machen, dann stellt man halt oft fest, ich brauch da gar kein Pattern, in Python kann ich das einfach so hinschreiben, ja, da muss ich mir kein,

komplizierte, komplizierte Dinge ausdenken, mit denen ich halt irgendwie da jetzt Architektur-Dinge, mit denen ich da mit diesem Problem fertig werde, weil ich hab das Problem gar nicht.

Und das ist halt schon sehr nett, dass man halt quasi eine große Klasse von Problemen, die halt, ja, also auch das, dieses Buch wurde halt gefeiert als, wie man, das kann man irgendwie so programmieren, in die Hand geben, und dann kriegen sie das halt alles hin, wo sie sich vorher einen abgebrochen haben.

So in Python hat man einen Großteil dieser Probleme, hat man einfach nicht.

So loslegen, machen.

Ja.

Ja.

Und das ist halt schon sehr schön, das ist ein großer Vorteil.

Ähm, ja, also da würde ich, würde ich, würde ich sagen, ist halt auch eine, eine der Stärken von Python, dass, dass man halt quasi irgendwie einen Großteil der komplizierteren Programmier-Patterns nicht braucht, weil man kann es einfach so hinschreiben.

Ich meine, klar, natürlich auch in Python gibt es Sachen, die kompliziert sind, und nicht alle Patterns sind überflüssig, deswegen, also es gibt durchaus Sachen, die man da auch brauchen kann, aber es, es macht das Leben schon irgendwie leichter.

Ähm, ja, das, das ist, äh, das wäre so der Unterschied statisch getypt, äh, dynamisch, äh, dynamisch getypt.

Genau.

Ähm, den strengen Sprach hatten wir jetzt auch schon, im Vergleich zu den anderen Programmiersprachen, was wir auch noch, äh, haben, ist quasi, ja, eben binär, äh, kompiliert, das hatten wir aber auch eben schon ein bisschen abgelandet.

Ähm, na ja, dann gibt es natürlich Sprachen, in denen man, äh, quasi das Memory-Management selber macht, so C zum Beispiel, ähm.

Und da muss man immer so einen Zeiger durch den Speicher schicken, der genau sagt, wo man gerade ist.

Ja, also, genau, also, äh.

Hier ist halt irgendwie Speicher, und dann kriegt man einen Zeiger drauf, zurück, und dann macht man damit irgendwas, und muss halt hinterher dran denken, dass man diese Strukturen wieder freigibt, wenn man sie nicht mehr braucht.

Äh, oder, ja, wenn man Dinge freigibt, die man, äh, die, die eigentlich man noch braucht, und es passieren schreckliche Dinge.

Also, das ist, äh, kann man...

Und wie löst man das in Python?

In Python hat man damit nichts zu tun, das ist, äh, äh, sozusagen, äh, äh, da, das macht Python für einen selbst, es sei denn, man schreibt wieder so Low-Level-C-Module oder so, die irgendwelche Dinge tun, dann muss man das auch wieder selber machen.

Äh, aber, ähm, wenn man einfach sich in Python bewegt, dann hat man damit eigentlich nichts zu tun, weil das, das passiert dann automatisch, also, Python verwendet da ein System, nennt sich Reference-Counting, äh, also, es gibt da auch wieder einen Unterschied, also, in einer Sprache wie Java ist es ja auch so, da muss man sich auch eigentlich nicht drum kümmern, das macht halt auch der Interpreter, und dann gibt es halt noch Sprachen, die machen Garbage, äh, äh, äh, haben einen Garbage-Collector.

Wie Python?

Nee, ja, also, Python hat auch einen Garbage-Collector.

Garbage-Collector, aber, äh, ja, das ist ein bisschen kompliziert, leider, äh, aber hauptsächlich ist es ein Python, äh, Reference-Counting, sozusagen, äh, sodass man...

Das heißt, es zählt, wie oft ist irgendwas irgendwo da, und wenn es nicht mehr da ist, dann zahlt es weg.

Genau, wenn, wenn irgendwo eine neue Reference entsteht, dann wird das halt hoch, wird der Reference-Counter hochgezählt, und, äh, irgendwie ansonsten, wenn, wenn eine Reference, äh, verschwindet, gelöscht wird, dann, dann wird es runtergezählt, und wenn es bei Null ankommen wird, wird das, äh, Objekt abgeräumt, ähm, und, äh, das hat den, das hat den großen Vorteil,

äh, es ist ziemlich schnell zur Laufzeit, und, äh, es ist, äh, sozusagen auch sehr einfach, ja, also kann nicht viel schiefgehen, äh, es sorgt für vorhersagbare Latenzen, äh, äh, es hat aber auch einen großen Nachteil.

Okay.

Der große Nachteil ist, äh, ja, man kann dann nicht mehr Parallel-Dinge machen.

Oh Gott, oh Gott, oh Gott.

Also auf unterschiedlichen Prozessoren. Das geht im Grunde nicht mehr.

Also das kann, könnte man tun, da muss man halt, äh, wenn man es naiv machen wollte, müsste man dann für jede Operation, die jetzt irgendwie so ein Ref, äh, Reference-Counter hoch- oder runterzählt, da müsste man irgendwie so ein, so ein Lock draufmachen und sagen, so, jetzt mal alle stopp, äh, wir, wir erhöhen jetzt diesen, diesen, diesen Reference-Counter, und dann können alle wieder weitermachen.

Wenn man das tut, wird alles ungefähr 40 Mal so langsam.

Und das geht alles einfach nicht mehr.

So, äh, ich glaube, ähm, Leute haben irgendwie lange dran gefeilt, sind jetzt auf Faktor 20 oder so runter, wo man gar nicht gedacht hätte, dass es überhaupt möglich ist.

Aber, äh, das heißt, du brauchst 20 Kerne, damit du dann den einen Kern, die Performance von einem Kern hinkriegst, genau.

Äh, das ist natürlich irgendwie nicht so richtig effizient.

Also, äh, das ist natürlich ein großer Nachteil.

Und dafür gibt's halt bei, bei Python auch den, den, den Global Interpreter-Lock.

Den, den bitte was?

Ja, GIL oder Global Interpreter-Lock, das ist sozusagen, äh, ein Ding, was dafür sorgt, dass, äh, quasi, äh, ein Python-Prozess nur auf einer CPU läuft.

Und nicht, äh, ein, ein Python-Prozess auf mehreren CPUs laufen kann.

Ja.

Ähm, das ist halt so.

Also, das ist auch der Grund, warum Java das nicht macht.

Java, äh, macht, äh, einen Garbage-Collector und hat dann dieses Problem nicht.

Ja, das kann dann halt auf mehreren Prozessoren laufen, problemlos.

Oder, naja, problemlos, aber geht.

Und, äh, sozusagen, muss dann halt ab und zu mal aufräumen.

Dafür ist eben dieser Garbage-Collector.

Das heißt, auf einmal gibt's eine Pause.

Nee, der Müllteil ist voll.

Jetzt muss der Müll aus, muss erstmal alles einsammeln.

Und wegfahren.

Genau.

Das, das Problem ist, man weiß halt nie genau, wann der zuschlägt.

Und dann, das bedeutet halt, dass man, wenn man einen Server laufen hat, dann kann das

halt sein, dass man irgendwie plötzlich, es sind halt alle Requests super schnell und

dann plötzlich einer dauert halt lang.

Also jetzt, um da bei dem Müllauto-Beispiel zu bleiben, kann man nicht einfach messen,

also wie voll der Müllcontainer ist und, äh, dann irgendwie den Müllwagen so gut fahren

lassen, dass der ein Routenmanagement macht und da richtig vorbeifährt und die Sachen

rechtzeitig lädt, bevor die vollgelaufen sind?

Ja, aber das Problem ist halt, du musst irgendwann halt alle...

Weiß nicht, wie viele Leute die Müll essen und wie viel Müll die wegschmeißen immer,

oder?

Ja, ja, ja, also da wird auch eine ganze Menge gemacht und es funktioniert auch alles

irgendwie so ganz okay, aber das Problem wirst du im Grunde nicht los.

Du hast immer das Problem, dass wenn, wenn der Müll weggebracht werden muss, musst du

allen sagen, so jetzt mal stopp, jetzt muss erstmal der Müll weggebracht werden.

Aber die schmeißen alles in dieselbe Mülltonne.

Ja, und, äh, dann, ja, selbst wenn das sehr schnell ist, kann es halt sein, dass es, weiß

ich nicht, 200 Millisekunden dauert oder sowas.

Könnte man nicht einfach eine kleinere Mülltonne machen?

Also für jeden so eine kleinere Mülltonne, als wenn man so eine große hat?

Ja, ich weiß es nicht.

Aber dieses Problem ist...

Aber dieses Problem ist nach wie vor da, also nach wie vor kämpfen da Leute mit.

Sagen wir mal, das ist halt einer der Trade-offs.

Wenn du halt einen Garbage Collector hast, dann hast du halt, dann kannst du halt irgendwie

Sachen auf mehrere Prozessoren verteilen, aber du hast halt den Nachteil, dass deine

Latenz so ein bisschen unvorhersagbar wird.

Ähm, ja, das ist halt blöd.

Und, ähm, ja, das, äh, das sind halt, man kann sich halt überlegen, was man irgendwie

lieber mag, äh, sozusagen.

Und auch da, äh, finde ich, dass Python da eine ganz gute, äh, ganz gute, äh,

gute Wahl getroffen hat mit dem Reference Counting.

Und auch da gibt es halt den Garbage Collector, den gibt es halt vor allen Dingen

dafür, dass, wenn jetzt so zirkuläre, äh, Referenzen irgendwie, äh, so wenn das

ein Objekt hat, das auf ein anderes verweist, das auf ein anderes verweist, das

eine Referenz auf ein drittes hat und das wieder auf das erste oder so, dann...

Die Katze beißt dich in den Schwanz.

Ja, dann werden die durch Reference Counting nicht weggeräumt, dann muss man

auch, muss auch Python ab und zu mal einen Garbage Collector anschmeißen, um

solche Sachen zu finden und dann rauszuwerfen.

Aber...

Aber einen Garbage Collector kriegt man bei Python mit sowas wie Import DC dann, oder?

Ja, genau, genau.

Äh, und der macht manchmal auch blöde Sachen und auch da hat man dann halt

manchmal so die Probleme, die man von anderen Programmiersprachen kennt.

Also wenn man zum Beispiel, ich weiß nicht, ob das heute noch so ist, aber

früher war das immer so, wenn man größere Datenmengen irgendwie importiert

hat per CSV oder weiß ich nicht.

Also ich habe früher irgendwie viel so, äh, Import-Export-Skripte auch

geschrieben und, ähm, da war also einmal einer der Tricks halt, dass man, äh,

quasi bevor man halt so ein paar Millionen, äh, Zeilen irgendwie gelesen

hat und die irgendwo reingeschrieben hat in irgendeine Daten, Hauptspeicher

Datenstruktur, ist halt, äh, einmal den, den Garbage Collector, äh,

ausgeschaltet hat.

Dann hat man den ganzen Scheiß importiert und dann hat man ihn wieder

angeschaltet.

Und, äh, weil ansonsten schlägt er halt alle paar tausend Zeilen oder so

zu und, äh, blockiert alles.

Und das macht es halt dann irgendwie direkt ein paar Faktoren schneller oder

so, ne?

Das, äh, heute kann sein, dass heute alles nicht mehr nötig ist und es

besser geworden ist, aber, ja, also da...

Ich bin echt neugierig, müssen wir vielleicht auch mal, äh, rausfinden,

ob das wirklich noch so ist.

Ja.

Wenn man das wirklich immer machen muss, dass man im Müllwagen sagen muss,

nee, heute nicht.

Ja, genau.

Und dann...

Also wenn man weiß, was passiert, wenn man sagt, ich, so, ich hau jetzt eine

Zeug, einen Hauptspeicher, ich weiß, dass es so ist und es ist richtig

so, da muss nicht geguckt werden, ob das irgendwie jetzt, ob davon was

weg kann, weil davon kann noch nichts weg, weil ich hab noch nichts

anderes gemacht, dann kann ich halt sagen, okay, ja, da soll jetzt momentan

nicht, äh, muss der Müllwagen nicht rumfahren, ne?

Das ist, äh, eher sein Nachreden, ja.

Aber ist natürlich schon hässlich, denn mit solchen Dingen will man sich

eigentlich als, als, als Entwickler ja gar nicht so beschäftigen müssen,

weil das ist natürlich irgendwie, ja, für die meisten Leute alles, äh...

Ja, also ich glaube auch, unsere Anfänger haben wir gerade vielleicht

wieder ein bisschen abgehängt.

Ich hoffe, wir holen die noch wieder ein bisschen ein.

Ich hoffe, wir...

Ich finde das alles so interessant wie, äh, ich.

Ähm, vielleicht kommen wir dann noch ein bisschen wieder zurück zu dem,

äh, was wir jetzt durch hatten.

Ich glaube, wir haben jetzt so ein bisschen erklärt, wie

Python jetzt funktioniert.

Ich weiß nicht, ob wir dazu noch ein bisschen was sagen möchten.

Lass mich mal gerade überlegen.

Also, äh, ja, äh, ne, ich glaube, äh, ja, nö, also im Grunde, im Grunde

sind das so die wesentlichen Unterschiede zu anderen Programmiersprachen, ja.

Ja, ja, okay.

Das heißt, die Unterschiede haben wir jetzt so ein bisschen erklärt,

was man damit also machen kann.

Äh, vielleicht wollen wir ein bisschen noch drauf eingehen,

was so die Mythen dieser Sprache sind.

Also, ja, das ist total einfach.

Ja.

Ne, das ist immer so einer der Sachen, fand ich jetzt tatsächlich auch,

also von der Syntax her.

Ja.

Da darf ich gut lasen, ja, dass du nicht irgendwie da standest und

hast irgendwie wie ein C, so ein Hello World, wo es dann irgendwie über

mehrere Teilen geht oder wie in Java, wo dann erst mal gucken muss,

ah, wo geht denn jetzt diese Funktion hin?

Steht da Print Hello World fertig?

Genau, genau, ja, weil bei Java, da muss man dann erst irgendwie

komische, so erst eine Klasse definieren und dann irgendwie, äh,

Public, Static, Void, Main oder sowas hinschreiben, wo es dann

Static, Void, Main ist halt so, irgendwie so magische Worte,

damit irgendwas passiert, so, aber ein Python-Stamm einfach

printen, wenn man printen möchte, das ist schon sehr nett, ja.

Ähm, ja, äh.

Also bleibt Python denn so einfach, wenn man das macht?

Ja, ja, nein.

Also, äh, ja, man kann auch.

Kommt davon, was man damit machen will.

Ja, ja, ja, man kann da auch.

Man kann auch Netzwerkkram damit machen, das hatten wir noch.

Ja, und, äh, ja, genau, und asynchrones Dinge und überhaupt,

ja, da, da kann es auch dann relativ,

fies werden.

Das Dumme ist nur, das ist halt dann,

wenn man fiese Probleme hat, dann, dann

kann man da nicht viel dran tun, dann, äh,

muss man leider, äh, leider manchmal

den sauberen Apfel beißen, aber ich, ich meine,

äh, es ist ja auch schön, wenn, wenn

quasi, äh, schwierige

Probleme möglich, äh, äh,

schwierige Sachen möglich sind.

Das macht einen mächtigen Tauberstab, ja, also noch mehr Magie, ja.

Aber es gibt tatsächlich auch Situationen,

wo man dann halt auch, äh,

komplizierte Dinge tun, tun kann,

beziehungsweise muss, und, ähm,

ähm, ja, wo es manchmal auch nicht so richtig offensichtlich

ist, was Python da, da tut.

Ja, und es gibt halt

auch so Ecken, die halt einfach nicht schön sind, das,

das muss man natürlich auch sagen.

Ich sag mal, wenn ihr jetzt einfach irgendwelche Daten von irgendwelchen Sensoren packen

wollt in eine Datenbank, das ist ja dann relativ, äh,

ja, für die meisten Sachen geht das, äh,

ähm, genau, ja, also

es ist einfach so,

es ist, es ist, würde ich sagen, tatsächlich sehr, sehr

einfach, es ist, es ist schön, wenn man irgendwie

auf Stack Overflow schaut oder einfach googelt nach

irgendwelchen, wie mache ich denn jetzt dies oder jenes,

dann ist es toll, weil, äh,

ja, das funktioniert halt meistens immer noch,

selbst wenn der, wenn die Antwort, die irgendjemand gegeben hat,

15 Jahre alt ist oder so. Es gibt tatsächlich auch

relativ viele Antworten mittlerweile, das ist, äh,

auch sehr angenehm, weil fast

für alles, für jedes einzelne

Problem, das man irgendwo hat, irgendjemand das schon mal

hatte und irgendwie so eine Musterlösung findet oder

auch das Problem dann von mehreren Seiten angucken

kann und, ja.

Aber, ja, genau, also das ist, äh,

das Python einfach ist, würde ich sagen, ist ein

Mythos, der durchaus irgendwie

mehr Wahrheit als, äh, Mythos ist.

Ähm, ja, ein

andere Geschichte wäre halt irgendwie, oh,

dieses Significant Widespace, das ist ja

total furchtbar, das kann da, ich, da,

ich kann so nicht arbeiten.

Significant Widespace, für alle Leute, die

jetzt gerade zum ersten Mal in der Sprache zuhören,

ähm, bedeutet, dass tatsächlich, ähm,

man darauf achten muss, wo was

in dem Code steht von Python.

Ja, dass man halt nicht, äh, quasi

den Code beliebig formatieren kann, sondern, dass

halt Widespace halt auch zur Syntax gehört.

Also, dass, wenn ich jetzt, äh,

ja, also, wenn ich eine

Zeile, die im gleichen Block ist,

äh, anders einrücke als die andere, dann

geht das halt schief. Also, das, was, äh, ich sag mal,

ein guter Programmierer von vornherein

formatieren sollte in seinem Code, das, äh, sagt Python,

wenn du es nicht machst, dann, äh, stürzt es ab und sagt,

nee, nee, nee, du, aber nicht. Ja, genau.

Ähm, ja.

Und es ist natürlich doof,

wenn man sich so ein anderes Schema angewohnt hat, irgendwann mal.

Genau, äh, und man kann das halt nicht beliebig

einstellen, ne, oder wenn man jetzt Tabs

und Spaces mixt oder so,

überhaupt, man kann Tabs auch verwenden zum Einrücken,

aber das, äh, sollte man nicht tun, das ist böse.

Immer schön Spaces verwenden.

Leerzeichen pro Ebene.

Und die meisten IDEs hier bauen

das auch irgendwann um, das heißt, ihr könnt das so bauen, dass ihr dann

vier Spaces pro Tab

bekommt, da könnt ihr wieder im Tab arbeiten, aber

es wird umgewandelt und ansonsten habt ihr tatsächlich manchmal Probleme,

wenn ihr irgendwelchen Code Freunden schickt

oder Code von Freunden bekommt, die haben Tabs benutzt

und ihr leerzeichnet, dann funktioniert das nicht mehr und ihr

seht nicht genau, warum, weil irgendwo

irgendwelche Leerzeichen dazu führen, dass, äh,

ja, da unterschiedlich interpretiert

wird und dann stürzt das ganze Programm ab. Hässlich.

Gerade für Anfänger manchmal, stehen

davor und denken, was, warum, geht nicht.

Ja.

Also, ich würde sagen, so ein bisschen

was ist ja da ja drin, also ich dachte

auch am Anfang, also ich kam ja dann

zu der Zeit, wo ich mich

angefangen habe zu beschäftigen, auch von

Perl her, wo man das halt nicht hat, wo man

das kommentieren kann, wie man will und so, und ich dachte auch so,

oh, das ist aber blöd, dass man da jetzt irgendwie, dass

man darauf achten muss, aber das waren

halt ein paar Tage und danach war's

super und ich fand

das nie wieder problematisch.

Ähm,

aber ich kann

so ein bisschen verstehen, dass es,

äh, blöd ist, wenn man das selber dafür sorgen muss, dass

die, äh, äh, quasi,

äh, dass die Formatierung

so ist, dass die Syntax stimmt, äh,

würde aber auch sagen, dass man

das heute eigentlich nicht mehr macht. Also andere

Sprachen machen ganz viele Klammern oder Semikolon

oder sowas. Ja, das ist halt der, der, der Preis,

den man dann zahlen muss, wenn man halt quasi eben nicht

die Formatierung, äh, äh, Teil

der Syntax, äh, als Teil der Syntax

hat, sondern sagt, okay, du kannst formatieren,

wie du willst, dann muss man halt irgendwie anders signalisieren,

wo ein Blockanfängten aufhört. Und dann,

dafür benutzt man halt typischerweise Klammern.

Und das heißt,

man hat halt sehr viele Klammern. Was halt,

kann ich dir mal erzählen, fünf Klammern auf, sechs Klammern zu.

Genau, genau. Und das ist halt auch

nicht so richtig schön, ne. So ein Python ist

diese Frage halt nie so, muss ich da jetzt noch eine Klammer,

also, man hat sie auch an anderer

Stelle, aber bei, jedenfalls nicht beim

Schließen von Blöcken, so, muss ich da jetzt noch eine Klammer zumachen

oder nicht, sondern, ne, wenn ich den jetzt da eingerückt

habe und aufhöre, dann ist dieser Block vorbei.

Das ist halt, äh, viel einfacher.

Ähm, ja.

Und, äh, genau, heutzutage

auch schon gar nicht mehr so ein Problem,

weil heute, würde ich sagen,

sollte man Code eigentlich gar nicht mehr unbedingt

selber formatieren, sondern man schreibt es halt

irgendwie hin, dass man, man denkt, dass es halbwegs passt.

Äh, und dann nimmt man

halt sowas wie Black. Das ist jetzt so ein

Ding, was halt... Black.

Ja. Schwarz. Genau. Ja.

Das ist so ein, äh,

Kommandozeilen-Utility, äh, man kann

das, äh, Wim-Plugin für den Editor

oder so, und dem sagt man einfach nur,

okay, reformatiere alles so, dass es

irgendwie läuft, dem Standard entspricht

und dann formatiert das den Code halt um.

Aha. Und dann muss man da selber

nichts mehr machen. Muss man das importieren, oder ist das

ein Kommandozeilen-Tool? Das ist, das ist ein Kommandozeilen-Tool,

aber, wie gesagt, es gibt für die meisten

Editoren Plugins, die das dann halt aufmarschen.

Diesen würde ich mir direkt mal aufschreiben, hier. Wieder was gelernt.

Genau.

Äh...

Ja, also, ich würde sagen, heute,

heutzutage sollte man eigentlich nicht mehr von Hand

formatieren müssen, das ist, äh, macht man einfach nicht mehr.

Ähm,

genau, damit ist das im Grunde

alles kein, kein Problem mehr, weil,

äh, ja, man hat ja

als Mensch gar nicht mehr damit zu tun, man muss

sich gar nicht genau mehr drum machen.

Man kann den Code in eine Zeile schreiben, das funktioniert weiterhin wunderbar.

Ja, man kann tatsächlich

relativ viel in eine Zeile schreiben, aber dann,

Python muss man das dann auch signalisieren, dann schreibt man ein

Semicolon, wenn man Statements voneinander erfahren möchte.

Ja, das Semicolon gibt's auch in Python.

Man muss es normalerweise nicht hinschreiben, weil der Zeilenumbruch

das ist halt quasi gleiche...

Aber wenn man es hinschreibt, tut's nichts.

Wenn man es hinschreibt, da kann man auch alles in eine Zeile schreiben, ja, das geht.

Nicht, dass man das wirklich tun sollte, aber...

Das sieht ziemlich arg wie aus.

Ja, äh, genau.

Ja, also, das ist, ähm,

das ist eine Geschichte,

die halt immer wieder als, oh, das ist ja total schrecklich

angebracht wird, aber ich würde sagen,

einmal, sie ist nicht so schrecklich, und zum zweiten,

heutzutage nicht mehr, kein Problem mehr eigentlich.

Hier ist gerade der Piep, muss man eine Pflanze gießen jetzt, oder?

Nee, meine, ich hab vergessen,

meine Uhr zu sagen,

dass sie nicht stören, dass sie nicht rumlaufen soll.

Bei der Pieps-Goal, ja.

Ja, und deswegen piepst es bei mir.

Ich mach das gerade nicht auf lautlos.

So, äh, und, ähm,

eine andere Geschichte ist,

ja, genau, Python ist langsam.

Das ist auch immer etwas, was man halt hört.

Äh, oh mein Gott, nein!

Was tue ich jetzt?

Ich bin viel schneller mit, äh,

Ja, man muss irgendwie das in Go neu schreiben,

oder in, keine Ahnung, oder in C,

oder C++, viel besser, weil viel schneller.

Und, ist es langsam?

Äh, ja und nein.

Also, es kommt halt tatsächlich,

also man kann, solche pauschalen,

äh, äh, Urteile sind halt

immer falsch eigentlich,

deswegen, weil man das,

ja, man muss halt immer, äh,

quasi konkret sagen, was man damit meint,

wenn man, äh,

wenn man jetzt sagt, dass es schnell oder langsam,

und halt in einem bestimmten Kontext,

in einem bestimmten Kontext geben,

und dann kann man das halt sagen.

Also, ich könnte zum Beispiel sagen,

also, wenn ich, wenn ich Methoden aufrufe

in Python, dann dauert das,

ist das halt deutlich langsamer als jetzt

in C++ zum Beispiel.

Das ist tatsächlich so.

Oder wenn ich eine Funktion aufrufe in C,

ist es viel schneller als, als in Python.

Ähm, also wenn ich halt eine Vorschleife mache

und dann tausendmal eine Methode aufrufe

auf einer Klasse oder so,

dann ist das in Python viel, viel langsamer

als in C oder in C++.

Insofern, äh,

in diesem Kontext wäre Python tatsächlich sehr langsam.

Aber die Frage ist halt,

was man, was ein Programm so tut.

Und wenn ich jetzt zum Beispiel irgendwie

große Matrizen mit dem Alter multipliziere, ja,

und ich mach das halt irgendwie mit zwei NumPy-Arrays

in Python, ja,

wo die Syntax sehr schick ist,

und ich das in einer Zeile tue,

und ich, äh, äh, jemand anders überlegt sich,

hat gehört, Python ist langsam,

und macht das halt in C,

mit so einer dreifach verschachtelten For-Loop

über halt, äh, irgendwelche Datenstrukturen,

weiß ich nicht, irgendwie so ein Type-Memory-View,

oder wo, wo auch immer man das in C,

wie man das in C hält.

Das ist ja ziemlich viele Zeilen lang, ja.

Äh, dann wird die C-Implementation

deutlich lang, wird halt deutlich langsamer sein

als die Matrizen-Multiplikation

in, in Python, die halt

man in eine Zeile schreiben kann, wo man einfach nur schreibt

A mal B, ja.

Also C gleich A mal B, ja.

Und das könnte jetzt für manche Leute

überraschend sein, weil

wenn, wenn quasi sich jemand

die Mühe gemacht hat, irgendein Problem,

äh, also wirklich da so das letzte Kränzchen

Performance rauszuoptimieren,

und es eine Bibliothek gibt, die halt

dieses Verfahren dann benutzt,

sozusagen in Python, und man das in Python

benutzen kann, dann ist das halt auch in Python sehr schnell.

Und, äh, grad diese ganzen Berechnungsgeschichten,

Certific Computing-Zeugs,

das ist halt alles sehr schnell

in Python.

Wie heißt das, C-Types, oder?

Nein, nee, C-Types ist nochmal

eine andere...

Entschuldigt, bitte.

Es ist auch so, dass man quasi relativ einfach,

äh, nein, also

eine Geschichte, mit der man dann halt

gut optimieren kann, ist auch

sowas wie CYTON zum Beispiel. Also C-Types ist nochmal

eher zum Anbieten von irgendwelchen

C-Bibliotheken, aber

äh, äh, es gibt sowas

wie, das hatten wir, das haben wir vergessen.

Das müssen wir vielleicht gleich nochmal, äh,

es gibt nicht nur den Python, äh, den

C-Python-Interpreter,

es gibt auch andere Python-Interpreter, und es gibt

halt auch so Dinge wie CYTON, die

Python, beziehungsweise Python-ähnlichen

Code nehmen und den

in C verwandeln.

Ja, also das haben wir ja gar nicht vergessen.

Wir erklären das doch einfach jetzt. Genau, genau.

Äh, wenn ich, wenn ich jetzt irgendwas schneller machen

möchte, dann gibt's halt die Möglichkeit, okay, ich schreibe

das jetzt einfach in C und, äh,

muss mich da an ein paar Konventionen halten,

dann kompiliere ich das und dann, äh,

quasi importiere ich, kann ich das

halt in Python auch wieder importieren,

als wäre es ein Python-Modul oder so, und dann halt verwenden.

Aber ich schreibe einfach C-Code und

dann wird dann Python geladen, ich benutze die Python-Syntax

und bin schnell dabei, oder? Ja, ja, ja,

so ungefähr, das ist halt ein bisschen Arbeit,

aber das geht. Ähm,

äh, und

das ist vor allen Dingen halt auch so ein bisschen, man muss sich da einlesen,

wie man das, wie man so ein, so ein C-Modul schreibt

und so, ähm,

aber was man auch machen kann,

ist, man schreibt halt ein, äh,

das, was man, was auch immer man machen möchte,

äh, in einem Python-ähnlichen

Dialekt, äh,

wo man halt auch,

man kann einfach so Python hinschreiben.

Python-ähnlicher Direkt, das haben wir ja schon ganz viel

Programmiersprache, es gibt ja nur noch Dialekte, also wird ja immer besser.

Äh, man kann, also der wesentliche Unterschied ist,

dass man dazu schreiben kann, was die Typen sind, dass man

zum Beispiel schreibt, also dies ist jetzt ein Integer,

oder das hier ist ein Float,

und so. Ja, also man schreibt halt quasi noch

Typen mit zu

den Variablen. Wie wir das eben schon hatten, also

das mit der neuen Version jetzt schon so drin ist,

genau, so kann man das auch machen. Es gibt Type-Annotationen, aber die sind halt leider noch mal was anderes,

das funktioniert nicht mit Type-Annotationen.

Okay, das heißt, nochmal ein bisschen umdrehen. Ja, könnte man

vielleicht irgendwann auch machen, das gibt's aber noch nicht.

Äh, jedenfalls, wenn man das,

wenn man das jetzt so hingeschrieben hat,

äh, in diesem Dialekt, der sehr einfach ist

und aussieht wie Python

quasi, äh, mit, mit Typen

dran, äh, dann kann man das

in C kompilieren, und zwar

in, in C, dass halt man dann hinterher

wieder so kompilieren kann, dass es ein

C-Modul ist, das man dann wieder importieren kann.

Ja, so dass man halt das eigentliche C nie

muss eigentlich nur Python, kleiner Gelekt schreiben

und schon ist es C und dann

wird es schnell, so schnell wie C

und ist dann so schnell wie C

Problem gelöst, würde ich sagen

genau, und das ist halt schon sehr cool, das kann man sogar

in Jupyter Notebooks, kann man das als

Cell Magic, kann man das schreibt man einfach Prozent

Prozent Zeiten, schreibt dann halt irgendwie

die Funktionen rein mit

Annotationen, das ist der Typen und dann hat man etwas, was

halt so schnell wie C ist, halt direkt

so ohne, dass man das irgendwie neu starten muss oder so

einfach so da, das ist halt schon

sehr, das sind

ja, also ich meine

wenn man solche Sachen Leuten zeigt, die sagen Python ist langsam

dann, oh

genau, also

man kann, wenn man es drauf anlegt, kann man

sehr schnell werden, auch in diesen

Geschichten kann man halt auch diesen Global

Interpreter Log deaktivieren, dann

kann man halt sagen, so okay, ich weiß ja genau, was ich tue, ich

deaktiviere das Ding

also da ist das alles nicht mehr so

relevant

also da kann ich dann auch mit mehreren Kernen rechnen

genau, da kann ich dann auch quasi

das, was ich tun möchte, auf mehrere Prozessoren

verteilen, passiert auch

also wenn ich jetzt irgendwie, keine Ahnung, eben eine Matrizen

Multiplikation, jetzt weiß ich gar nicht, ob das meine

wenn ich irgendwelche Dinge auf NumPy Arrays mache

oder in Pandas mache, manchmal

ja, nicht immer, verteilt es dann halt

den Kram automatisch halt auf

alle Prozessoren, die ich da habe

ja, ansonsten gibt es

auch jede Menge schöne Bibliotheken, die man da benutzen

kann für Data Science

Geschichten, ist da halt zum Beispiel

Dask sehr zu empfehlen, kann man sagen

Dask, ja, heißt so

Data Ask, Dask, ich weiß, ich weiß

gar nicht genau, wofür das steht

Dask, nur D

Da ist ein Dask

Ja, genau

und

ja, es gibt auch so, da gibt es noch diverse andere

Geschichten, es gibt zum Beispiel Number

das ist halt ein Dekorator, den schreibt man

drüber und dann macht das halt so

Just-in-Time-Kompilierung, wie man das halt auch

von Java vielleicht kennt

das kann Dinge auch total

beschleunigen, da muss man gar nichts ändern, also

auch da kann man dann wieder Typen dazuschreiben oder so

aber auch da, oft ist es so, man

schreibt das einfach drüber und die Funktion wird viel, viel schneller

und

PyPy oder sowas habe ich noch

genau, das ist ein anderer Interpreter, den man verwenden kann

der hat dann diverse Probleme, nicht halt

der macht auch so

Just-in-Time-Kompilierungsgeschichten

und so, und ist dadurch

viel schneller, PyPy ist ein bisschen problematisch

das hat irgendwie

ist nicht mehr so auf der aktuellsten Version

von Python und

ist so ein bisschen leidet darunter, dass da nicht so genug Leute

dabei sind

es gibt auch

Stackless-Python

also es gibt noch diverse andere Interpreter

es gibt nicht nur den C-Python-Interpreter

aber man muss schon sagen, der C-Python-Interpreter

ist natürlich eigentlich derjenige, den

die Leute so verwenden und den man halt kennt

und auch die Referenz-Implementation

aber wenn man jetzt

in einem bestimmten Szenario mehr Performance braucht, dann kann es

durchaus sinnvoll sein, da halt sowas wie PyPy zu sein

also trau niemals den Benchmark, so wie ich

selbst gefälscht habe

ja, genau

ja, genau

ja, das ist auch so einer der Mythen

irgendwie Python ist langsam, was haben wir denn noch so

ja

also wir wissen, dass

Python jetzt einfach ist, wir wissen, dass

Python nicht langsam ist

oder nicht langsam sein muss

wir wissen, dass man für Python ja trotzdem ganz viele

mächtige Werkzeuge benutzen kann, wenn man dann

irgendwann mal gelernt hat, wie

ja

fällt dir noch was ein?

nö, zu hart

warum hat Python so lange gebraucht, bis es sich so

durchsetzte, was glaubst du?

das ist eine gute Frage, also ich hätte damit auch gar nicht

gerechnet, dass es jetzt passiert, also wenn mich jemand

quasi am Anfang

meiner Python-Begeisterung gefragt hätte, ob ich glaube

dass sich das mal so durchsetzt, dann hätte ich gesagt

ja, auf jeden Fall, und ich hätte wahrscheinlich

geschätzt, dass es viel weniger lang

dauert

und jetzt da angekommen ist, sagst du, es gibt auch gar keine Alternative

also auch Go, sagst du, das war ganz fancy stuff

aber

nein, das ist auch alles schön, also ich meine

ich finde Go auch toll, ich finde auch Rust toll

das hat alles schon so auch

vor allen Dingen andere Trade-offs

und ich meine, gut, das sind auch alles manchmal so sehr viel

modernere, also ich würde sagen, Go ist stark

die Go-Syntax ist sehr stark inspiriert

von Python

die also

ja, sind teilweise

sehr, sehr viel, also sowohl

Go wie auch Rust sind halt sehr viel jünger als

Python, insofern

ist das halt auch vielleicht nicht unbedingt direkt

miteinander vergleichbar, aber

Go ist halt einen schmaleren

Einsatzzweck, würde ich jetzt mal so

denken

vielleicht erinnert sich das auch noch irgendwann

und zwar, also wofür würdest du jetzt Go benutzen?

naja, Systemprogrammierung und halt Sachen, wo man

quasi

viel I.O. hat und

viel CPU braucht

das ist

also wenn man jetzt zum Beispiel sowas wie einen Datenbank-Server schreiben will

oder so, wobei ich nicht weiß, ob Go da wirklich

also ich weiß auch nicht, ob das jemand schon mal gemacht hat, aber das könnte man

eventuell tun

also

viel Sachen machen muss, heißt tatsächlich

Input-Output die ganze Zeit

Input-Output plus irgendwie viel CPU braucht

also wenn man nur Input-Output machen muss

und I.O. multiplexen, das geht in Python auch total super

dann nimmt man Async.io oder

die neuen Frameworks, die es da gibt

weiß ich nicht, Trio da

oder

was auch immer

Trio von David Beasley

von der Europython, das war auch sehr toll, aber ich glaube

das ist nur ein Dialekt von Async.io

Ja,

genau, die sind auch relativ

kompatibel irgendwie zueinander

das ist

genau, damit geht das auch alles total super

dafür brauche ich jetzt nicht

da

ist der

GIL nicht unbedingt ein Problem

der Global Interpreter-Log

ich kann auch mehrere Prozesse starten oder so

aber wenn ich jetzt sowas habe wie eine Datenbank

oder so, dann ist das mit mehreren Prozessen unter Umständen

blöd, wenn ich jetzt

also da könnte es sein, dass es sinnvoll ist

also, dass ich halt

ein Prozess starte und dann

einen Prozess habe, der halt auf vielen

Prozessoren läuft und dann auch

I.O. mäßig irgendwie ganz viel nach draußen macht

und da wäre Go wahrscheinlich super

ja, oder Rust hat halt auch

schöne Eigenschaften, dass halt da irgendwie

diverse Sachen garantiert sind

zur Compile-Zeit, das ist halt toll

ja, aber

Moment, jetzt musst du nochmal kurz erklären

sind die Sachen garantiert zur Compile-Zeit

da die bei Python nicht sind

da musst du jetzt ganz kurz nochmal versuchen

das so zusammenzufassen, das habe ich jetzt nämlich noch nicht so ganz

durchblickt. Ach, ich weiß nicht, vielleicht würde das auch ein bisschen

zu weit, also bei

Rust ist es halt so, dass man quasi

garantieren kann, dass es keine Speicher-Lags gibt und so

bei Python sollte das jetzt auch nicht passieren

wenn man das schafft, irgendwie

außer dadurch den Speicher wirklich zu

verbrauchen, also wenn man einfach nur irgendwas macht

also irgendwas erzeugt, irgendwas wieder

wegschmeißt und trotzdem

quasi der Prozess

der Speicher des Prozesses, den man da halt gestartet hat

immer größer wird, dann hat man halt einen Bug

gefunden, also gibt es natürlich auch

immer wieder, sollte

aber auch nicht passieren in Python

aber es gibt da nicht so harte Garantien

also das ist, und man kann es

auch kaputt machen, wenn man

irgendwelchen Unsinn anstellen, einen Gabel-Projektor importieren

dann drauf referenzieren auf die Objekte, die man da findet

ja, man kann da beliebig

kaputte Sachen natürlich machen

genau

ja

aber diesen Anwendungsfall

dass man viel I.O. und viel Prozessor

gleichzeitig braucht, den haben glaube ich

gar nicht so viele Leute, insofern ist es halt auch so

dass ich finde, dass der richtige

Schritt sozusagen, oder das, ich finde

das ist ein sehr netter Punkt

quasi, man hat, wenn man jetzt Reference-Counting

in Python hat

man hat halt gute

Single-Thread-Performance, man hat sehr gutartiges

Latenzverhalten, das alles

verhält sich alles sehr schön

gut verlierbar

damit dann auch, genau, opfert damit

halt sozusagen, dass es auf mehreren Prozessoren

laufen kann, aber

den Fall, dass man jetzt Software hat, die

tatsächlich auf vielen Prozessoren laufen muss

den haben die meisten Programmierer

gar nicht, ja, denn dieser Anwendungsfall

trifft ja nur einen kleinen Teil

Spieleprogrammierer

Spieleprogrammierer und unter Umständen ja, Leute, die

einen Datenbank-Server schreiben oder irgendwie einen Web-Server

ja, einen Web-Server nicht mal

oder ich weiß es gar nicht

mir fällt es sogar tatsächlich schwer

mir da

Anwendungsfälle zu bauen, die das

irgendwie erfordern

insofern ist halt diese Beschränkung

ist halt nicht so schlimm, wie sie aussieht

und in Java, das sieht total toll aus

auf dem Papier, irgendwie kann auf vielen Prozessoren

laufen

in der Praxis ist es aber blöd, das Single Thread Performance

ist nicht gut und

also das, was halt die meisten Leute interessiert, wenn sie

jetzt irgendwie irgendwas starten, ein Programm starten

und das tut dann irgendwas, dann ist es halt

das ist halt langsamer, ja, das ist halt

genau der Grund, warum, wenn ich jetzt in so einer

IntelliJ IDE auf den Kopf drücke

dann, dass es halt irgendwie sich alles so zäh anfühlt, weil

ja, Single Thread Performance ist nicht so toll

und

das ist, und Latenz

nicht vorhersagbar, klingt nicht so schlimm, ist

aber in der Praxis doof, weil manchmal

äh

zur falschen Zeit irgendwie, wenn was

mehr Latenz braucht, kann halt sein, dass es halt unter Umständen sehr teuer wird

äh, je nachdem, was man

da für Services betreibt und

ja, das sind eigentlich

das sind Dinge, die hören sich harmlos an, sind aber ziemlich schlimm

während in Python, das hört sich ziemlich schlimm an

ist aber gar nicht so furchtbar

und wenn man dann tatsächlich so eins von diesen Problemen hat, dann kann man halt

da drum herum arbeiten, oft, indem man

dann halt viele Prozesse startet

gut, dann muss man irgendwie dazwischen

kommunizieren, muss irgendwie vielleicht Chat Memory haben

oder solche Sachen, aber

aber

es geht

selbst wenn man jetzt in einer Sprache ist, wo es theoretisch möglich ist

das alles in einem Prozess zu machen, ist es auch oft

nicht so eine gute Idee, weil

äh, das dann oft sehr kompliziert

wird, äh, und man halt auch

ordentlich locken muss und

ja, wirklich sich

vorzustellen, was passiert, äh, wenn

ein Prozess auf mehreren CPU

parallel unterschiedliche Dinge tut

äh

das ist, das ist einfach für auch

die allermeisten Programmierer überfordert das total

also mich überfordert das total, also

äh,

du kannst nicht einfach multidimensionale Matrizen

in deinem Kopf schungieren, also

ja, also, ähm, das ist

so, und wenn man jetzt sozusagen

etwas, was zu schwierig für die meisten Leute ist

und selten gebraucht wird, halt, äh

sagt, das ist etwas, auf das optimieren

wir hin, dann ist das irgendwie einfach

naja, ich weiß nicht, ob das so sinnvoll ist, aber

ja. Wenn ihr anderer Meinung seid,

schreibt eine E-Mail, ne, an handels-

handels-podcast.de

Ja, also, ich meine, das ist jetzt nicht die

reine Wahrheit, sozusagen

sondern es ist natürlich sehr gefärbt

äh, ich mag halt Python, aber

ja

ich finde, die haben da einfach einen sehr schönen

Sweet-Spot, äh, quasi

Klingt, als ist das eine Sprache,

die auch zukunftsträchtig durchaus ist, ja

Achso, hatten wir das, hatten wir eigentlich das

äh, Send auf Python schon?

Nein, das haben wir noch nicht, äh, gemacht

das wäre jetzt tatsächlich am Ende der Mythen noch der Punkt

Vielleicht sollten wir das nochmal kurz, äh, äh

Send auf Python, das hört sich ja sehr philosophisch an, so ein bisschen

nach, äh, fernöstlicher

Philosophie

Wir rufen es gerade auf und, äh, möchtest

du es tatsächlich zitieren, oder?

Ich, ich, ich denke schon, tatsächlich, also man kann sich das

auch selber angucken, wenn man einfach so einen, so

Python startet, also einfach Python eingibt

und dann sagt import this, dann

äh, äh, erscheint

erscheint das und das, äh,

bringt halt so ein bisschen zum Ausdruck, was so

äh, Python

besonders macht oder, äh, wie man Dinge

in Python tut und wie sie vielleicht ein bisschen anders

sind, als man das normalerweise vielleicht gewohnt ist

und, äh,

ähm, ja, da sind halt eben solche

solche Dinge drin,

ich weiß nicht, ne, stimmt, also die alle durchgehen, muss man

vielleicht nicht, das ist halt

Ja, das ist

ja, kann man, kann man

Ja, ich glaube, das steht auch am Anfang von, von der

Pep, äh, Version, kann das

auch sein, also von dem Style Guide, den es

für Python auf der offiziellen

Seite gibt? Ja

Ich weiß nicht so genau, aber kann so, kann gut sein

Ich, äh, ja, dann halt

solche Sachen wie explizit ist besser als

implizit, ja, das ist halt auch, so man, man

merkt auch dem Ding an, dass es so ein bisschen sich halt

in, in, in viele, viele Punkte, äh,

sind so abgrenzend Richtung Pearl, glaube ich

Ja

Also, äh,

ja, das, äh,

einfach ist besser als komplex, ja, komplex

ist besser als kompliziert

Ja, äh, flach ist

besser als, äh, verschachtelt

Äh, ja,

äh, ja, sparse, weil ich das gar nicht

in diesem Kontext übersetzen soll, aber es ist halt

sozusagen, ähm,

ja, sparse ist better

äh, than dense, äh,

sozusagen, lieber übersichtlich

als, äh, also nicht alles in eine Zeile packen

Genau, genau, sozusagen, äh, ja

Lesbarkeit zählt

Also zwischendurch mal leerzeilen lassen, äh,

höre die Lesbarkeit ungemein

Ja, das ist überhaupt eines der Designziele bei Python gewesen, dass man

das halt, äh, weil

Code einfach viel öfter gelesen als geschrieben

wird, das vielleicht Sinn macht, das

darauf zu optimieren, dass man das gut lesen kann

Also wenn euer Nachbar den ja abends aus dem Bett klingelt, dann noch lesen kann, was

er da für ein Paar geschrieben hat, dann seid ihr vielleicht bei Python

besser aufgehoben als bei anderen

Sprachen, ja

Ja, ähm,

ähm, genau, ja, äh,

Spezialfälle sind nicht

speziell genug, um, äh, die Regeln

zu brechen, aber

Pragmatismus besser oder Practicality

äh, ist besser als, als, als die reine

Lehre als Purity

Wie lange schreibst du deine Zeilen?

Äh, ich hab das letztens

erst geändert, glaube ich, auf

130, ich glaube, ich glaube,

79, 130, 150, irgendwie so

Ja, ja, ich hatte das ganz lange, also bis vor kurzem

hab ich tatsächlich auch, äh, 79

verwendet. Also das für die Leute, die

alte Monitore verwenden, die konnten auch nicht mehr lesen

oder die halt gescherte Terminals verwenden mit mehreren Seiten

Ja, Terminals sind vor allen Dingen, genau

äh, ja, äh, dann

ist halt bei 80 Zeichen

Schluss und, äh, genau