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, also ja, mein Name ist Jochen,

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

Wie kamst du zu Python, Junge?

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,

auch ein paar der 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 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 Pal mehr.

Du bist schon ein ziemlich alter Hase, wenn ich das so sage.

Ja, alter Sack, ja.

Genau, und 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 da so ein Python alles machen kann.

Ja, deswegen bist du da.

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 Falken gekommen?

Ja, ich bin ein ziemlicher Rookie noch.

Ich bin jetzt insgesamt 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 bin dann über ein Python-Tutorial gestolpert.

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.

Oh, da klopft jemand an die Tür.

Das hat ein Spielzeug in der Hand.

Mhm.

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

Ja, das ist auf jeden Fall ein schneller Einstieg gewesen,

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, hab den ersten Code geschrieben und hab gedacht,

ja, genau, das wollte ich dann machen.

Stimmt. Hammer. Also

liegt bestimmt auch vielleicht an der Einfachheit der Sprache, aber

da kommen wir vielleicht ein bisschen später zu, was für

Features Python alle hat.

Ja, vielleicht fangen wir noch mal 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?

Ja, ich denke schon.

Das ist halt auch so

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,

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

und 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

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 zu gemacht, 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 uns 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.

Ihr könnt also auch ein bisschen gespannt sein, was wir jetzt auch 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 das ist schon gute, wie lange?

Fast 30 Jahre alt tatsächlich.

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

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 so 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, dann, 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, da haben sich auch 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, hat es quasi gepasst.

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 ich habe es halt verwendet in irgendwelchen Skripten und so.

oder irgendwelche Skripte angepasst und dann später so wirklich angefangen,

damit größere Dinge zu programmieren, habe ich dann mit Python 2.1 oder so.

Das war so 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 Standard-Bibliothek oder?

Ja, natürlich, also da ist einiges dazugekommen.

Aber das ist gar nicht so...

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 diverse Keywords yield.

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

Ich weiß nicht, wann 2.2 rauskam.

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

was heute eine große Rolle spielt.

Und damals war das halt alles noch gar nicht da.

Es ist alles, was irgendwie mit Async.io oder irgendwie, ja.

Wann kam das anfangen? Version 3 erst oder schon 2?

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

Und es 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, ganz viele Leute haben Twisted halt als Basisbibliothek

für ihren Netzwerkrahmen 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 irgendwie mit

Threads konnte man auch eigentlich quasi das schon

immer machen, irgendwie so IO-Multiplexen,

das ist halt das, was man vor allen Dingen macht, wenn man

jetzt irgendwie quasi

so asynchron

Dinge tun will.

Aber so wirklich schön war das alles nie und

jetzt inzwischen ist es aber,

gibt es da halt eine nette Syntax

für und das ist eigentlich ganz toll und das machen

ganz viele und genau,

das war damals alles noch

ganz weit entfernt.

Ja, dann, ach so, auch damals, was dazugekommen ist, Newstyle-Classes, das...

Was?

Newstyle-Classes.

Newstyle-Classes.

Genau, die Klassen waren etwas anders davor und ja, genau, jetzt müsste ich noch nachlesen, was da genau die Unterschiede waren.

Ich glaube, also eigentlich weiß ich nur, dass man halt quasi dann immer nicht Doppelpunkt,

also Leerzeichen, Class, Name, Doppelpunkt geschrieben hat,

sondern irgendwie die ganze Zeit lang hat man immer auf Object geschrieben,

damit es halt von Object erbt und man New Style Classes automatisch verwendet,

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

Also jede 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.

Okay.

Ja, dann... Ach so.

Auch eine neue Syntax, die

sehr praktisch ist.

Das ist halt so...

Also es gibt List Comprehensions,

glaube ich. Die gab es auch nicht, aber dann?

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,

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 ein Generator ist. Das könnte sein,

dass das erstmal zwei, vier war oder so.

Und jetzt gibt's

auch irgendwie so

Syntax für Dict-mäßige

Objekte. Also man kann halt auch geschweifte Klammer auf

und dann

V-Doppelpunkt

K-Komma

v in irgendein Addict.items

sagen und dann würde sich

Also kann man sich sein Addiction erst generieren.

Ja, genau. Und muss dafür

nicht extra irgendwie

nochmal Addict aufrufen oder so.

Ja, das ist jetzt, das ist aber dann

relativ spät dazu gekommen. Ich glaube, das ist erst

mit Python 2.3 oder Python 3

dazu

gekommen jetzt. Wofür

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

Also am Anfang war es vor allen Dingen eine Skriptsprache zum Verbinden von irgendwelchen Systemen.

Man nannte die Dinge auch Glue Languages und so, weil es schön einfach ist, diverse andere in anderen Sprachen programmierte Libraries anzubinden und die dann halt irgendwie miteinander zu verbinden.

Hast du verschiedene Server-Module mit Python-Kleister dazu geklebt?

Ja, irgendwie sowas wie man hat Image Magic 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 E-Mails mit Bildern drin verschicken oder sowas.

Solche Sachen hat man halt in Python vor allen Dingen gemacht.

Weil man hat einmal das Bild in der Hand

und man hat einmal eine E-Mail in der Hand

und Python gibt dann den Kleber, dass man eine E-Mail mitbildet.

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 zum Beispiel Flask, habe ich in einem Tutorial

gelernt, und natürlich Django.

Ja, die kamen allerdings alle

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, bitte, deswegen sind wir 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 Webserver 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.

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 Webserver mit

einem

Skript kommunizieren kann,

dass man halt irgendwie diesen Kram

liest und wegschreibt, gibt es

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 installiert

hatten und deswegen man keine Python-Skripte

als CGI-Skripte irgendwie da

angeben konnte, aber

Musste man selber

hosten, wenn man Python-Skripte hatte. Ja, 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 nix.

Also es gab

also das ist halt auch, da gab es

eigentlich nur PHP. Also da gab es Mod-PHP

für den Apache.

Es gab auch einen Mod-Python, aber das war ziemlich

furchtbar. Das habe ich mal versucht zu verwenden.

Ich habe es sogar eine ganze Zeit lang verwendet, aber das war alles

ziemlich scheußlich.

Hatte Memory Leaks, war alles irgendwie

ätzend, dauernd so komische Sachen passiert.

Also Memory Leak heißt

dann, der Server stellt ab, wenn den Leute benutzen.

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.

Das ist nicht so schön. Das Mod-PHP war auch

nicht so toll, aber das hat halt so schon irgendwie ganz gut

funktioniert und

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 war es das erste,

was Leute tatsächlich da

in Python gebaut haben, war

Soap.

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

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 es 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.0.

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

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

Ja, aber das waren so die ersten, genau.

Und dann kam halt

mehr dazu,

als es eine standardisierte,

schöne Schnittstelle gab. Also es gab dann diverse Schnittstellen,

die auch besser funktioniert haben als CGI.

Es gab fast CGI.

fast CGI? 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 und dann konnte man das irgendwie, dann wurde

und die Daten da halt irgendwie

in der Prozesskommunikation 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,

müsste dann so Mitte der Jahre gewesen sein,

da gibt es dann halt, seitdem gibt es irgendwie

Mod, gibt es halt Whiskey

sozusagen als Schnittstelle zwischen Web-Server und

Applikation. Also

sich das so halbwegs standardisiert hat.

Hört sich nach etwas ziemlich Holzigen zu trinken

an.

Ja, also wird aber

WSGI 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

Web-Server 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 irgendwie den Servern, die halt statische Verhalte 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 Lite, HTTPD und so.

Und heute vielleicht, 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, muss da nicht irgendwie...

Also bei Nginx, also ich habe mich

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

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 Mew, wie ist GI, oder U, wie ist GI, 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 diese Server und die rufen dann halt eben quasi die Applikation mit der entsprechenden API auf.

Also ich wollte jetzt gar nicht unterbrechen,

ich fand es nämlich auch super interessant.

Ich glaube, wir machen vielleicht sogar noch eine eigene 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.

Deswegen müssen wir noch ein bisschen mehr eingehen darauf,

welche Funktionen man mit Python vielleicht noch machen kann.

Also wir haben jetzt vielleicht einen kleinen Einstieg

schon mal euch gegeben, was es so an coolen Möglichkeiten

heute so 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 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ählte 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 auch YouTube ist in Python.

Ja, genau, YouTube ist so ein bekannter

NASA, macht viele Sachen mit Python.

Ja, bei Disney zum Filme

produzieren und

Ja, Pinterest auch. Ich weiß nicht genau, die waren sogar Django irgendwie. Aber auch 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.

Ja, also dieses Glue-Ding 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.

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

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

Python, die Jupyter-Notebooks, die es jetzt gibt.

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 oder wie man zu einem bestimmten Ergebnis gekommen ist.

Sehr, sehr gute Idee halt.

Hat sich nie so richtig

durchgesetzt, weil Mathematik 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 Ripple, weiß gar nicht

wofür diese Abkürzung, also diese

Shell, die man bekommt,

wenn man jetzt Python eingibt.

Was sie IPython jetzt in dem

Falle tatsächlich. Ja, die haben

die haben halt sozusagen das damit

reingebaut und das nannte sich dann IPython Notebook.

Also IPython hatte 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 Mathematica-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 sehen,

Dann wurde das halt umbenannt in Jupiter, wobei das halt nicht

Jupiter wie der Planet geschrieben wird, sondern mit

P-Y, halt wie für Python, weil

es dann 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, so

das zu umschreiben, jemanden,

der das nicht kennt, quasi

warum das toll ist,

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

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

Und dann hat man das Ergebnis.

Irgendeine Berechnung, genau, die man macht.

Irgendwann trainiert man 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 erzeugt man dieses Modell,

dann macht man da irgendwelche Evaluationen drauf,

dann visualisiert man das Ganze,

dann macht man da irgendwelche Tests.

Da muss man erstmal 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 jetzt baut man da einen blöden Fehler rein oder so.

Und das passiert einem tatsächlich,

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 Stunde Berechnung oder so ist weg

und man muss halt im Grunde nochmal eine Stunde warten.

Aber selbst wenn man nur ein paar Minuten warten muss,

ist es halt voll blöd, weil man ändert irgendwas,

probiert es aus, Zyklus halt,

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 und das Ergebnis

ist halt nicht weg und das ist halt super.

Wenn man sowas arbeiten möchte, ist das glaube ich...

Genau, und das macht einen halt viel, viel schneller.

Und das ist halt total toll.

Ist das auch für Anfänger sehr gut geeignet, würdest du sagen?

Auch zum Lernen der Sprache?

Ja, weil es halt so schön interaktiv 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ängertipps.

Ich glaube, das wäre gar nicht so schlecht.

Also wenn ihr Fragen habt, natürlich direkt irgendwie

an hallo.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.

Gleich mit ein paar Tipps anfangen.

Ich glaube, ganz wichtig ist natürlich die offizielle

Dokumentation. Aussage des Tools zum

Lesen. Ich glaube, da findet man so die meisten

Erklärungen für die Standardbibliothek, wie das alles

so funktioniert. Außerhalb 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.

wenn man sich da so durcharbeitet, kommt man relativ tief

in die Materie rein. Es gibt noch

Automated Boarding Stuff mit Python.

Geht auch auf deutschem Buch zu. Das kostet

leider Geld, ansonsten ist das ein kostenloses Tutorial.

Ja, die ganzen Tutorials gibt es sonst

nicht auf Datacamp, Udemy, Udacity,

unzählige kostenlose.

Ja, du hast ja gerade gesagt,

anfangen vielleicht mit Jupyter Notebook oder

einem einfachen Text-Titel. Also ich kann jetzt

nicht empfehlen, direkt mit einer großen Entwicklungsumgebung

zu starten. Das hält dann erst mal

so ein bisschen auf. Gibt ja dann

irgendwann später ganz viele tolle Editoren,

PyCharm, Idle, VS Code,

VEye, Atom, MX.

Was benutzt du?

VEye.

Ich benutze aber auch PyCharm

zum Beispiel mittlerweile, weil mich nervt, dass es halt

doch relativ langsam ist.

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 drauf drückt oder so, dann

muss man erst mal, es ist so...

Zu langsam. Es ist einfach zu langsam.

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 er drauf, und dann

passiert einfach nichts und dann drückt man nochmal

drauf und dann macht es irgendwie so

Kennt ihr das, wenn ihr euch gerade so einen Schokoriegel

aus dem Automaten ziehen wollt und dann bleibt der irgendwo da oben

hängen? Ja, und 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

WIM, da hat sich auch einiges getan.

Wie hast du denn Python gelernt?

hast du da irgendwie Tutorials

gemacht oder warst da direkt drin? War das so

Basics, dass man alles selber beibringen 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,

wie habe ich es gelernt?

Ich hatte das Glück, dass ich da neben jemandem gesessen hatte,

der das schon konnte.

Und wenn er mir das dann gesagt hat,

das war etwas lukriöse.

Das war relativ praktisch.

Das kann ich auch tatsächlich empfehlen.

Versucht nicht nur im stillen Kämmerlein zu sitzen

und euch selber durch den Kram zu quälen.

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.

Man könnte auch zu Meetups

durchaus gehen, sich da mit Leuten

austauschen hilft.

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, es verbindet halt zwei Dinge,

die eigentlich sich 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,

so ein mehr oder weniger Makro-Assembler,

da kann man dafür einen Compiler zuschreiben.

Warum muss man denn überhaupt etwas in Binärcode

kompilieren?

Wenn es ein Computer direkt ausführen

können soll, dann muss das irgendwie

Maschinencode sein.

Binärcode, Nullen und Einsen.

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 ja die 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 mal 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 dann der Preis, den 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 Bytecode verwandelt

und der Whitecode 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 der Python-Interpreter ist halt genau diese virtuelle Maschine

und der kann das dann halt ausführen.

Und 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

oder verschicken. Wieso, es gibt doch PIP.

Ja, genau, dann muss man dann eben zu

so Paketmanagern greifen,

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.

Also, wenn ich das richtig verstanden habe, PIP ist dann

dieser Paketmanager, der über die Seite

PyPy oder wie es ist, über den Server von dir

läuft und dann da Pakete

installiert, die andere dort bereitgestellt haben,

die schon so mit veröffentlicht sind.

Das heißt, wenn ihr eure eigenen Pakete baut,

müsst ihr die entweder so veröffentlichen oder

tatsächlich externe Bibliotheken

nehmen, um Installer zu bauen oder sowas.

Genau, das gibt es auch. Es gibt High-Installer,

es gibt diverse Geschichten, die das dann halt versuchen

irgendwie in Binary 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.

Bei Linux braucht man es, glaube ich, nicht groß.

Nee, da gibt es, glaube ich...

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

Nee, aber da gibt es auch, also unter Linux gibt es auch so ein Ding,

was halt quasi den Interpreter mit reinpackt in Binary.

Pye-Installer?

Kann sein, dass es Pye-Installer ist.

Und 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 irgendwie so 15 MB

sind oder 10, ich weiß nicht genau.

Aber man kriegt es auf irgendwie 2, 3 runter,

wenn man sich da ein bisschen Mühe gibt.

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

sowieso alles nicht mehr so wild.

Dann ist es halt so, es gibt natürlich Leute,

die sagen würden, wenn ich

das mit C mache und dann gut

und nicht gegen die Lip C linke

oder gegen die G-Lip C, sondern halt irgendwie

so eine Diät-Lip C

oder irgendwas anderes, keines.

Jetzt hören wir gerade kurz wieder. Lip C, G-Lip C,

das sind die Standardbibliotheken, die CISO bereitstellt

für die Befehle, die dann das Ganze größer machen,

wenn man das kompiliert, oder? Genau, da ist ein bisschen

Standardbibliothek dabei, aber eigentlich, wofür die da sind,

ist die Kommunikation mit dem Kernel,

mit dem Betriebssystem, sozusagen.

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 ein Mikrocontroller packen. Ich glaube, man kriegt das

sogar in so einen Bootsektor rein. Wie hat so ein Bootsektor

512 Bytes oder sowas?

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

ja, nicht mehr wirklich viel.

Luxus.

Früher war das doch sehr schlimm, heute...

Band zurückspulen oder sowas, ja.

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,

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

Preis, den man dann halt zahlt, dafür,

dass es halt einfach ist,

aber trotzdem sehr mächtig.

Und ja, also

Die Beine ruhig, das kriegt ihr natürlich

trotzdem auf der Python-Room-Stage direkt

für die jeweiligen Systeme und wenn das

Der Python-Interpreter selber ist natürlich

wieder quasi so ein Bein.

Einige Leute empfehlen auch Anaconda, das ist irgendwie so ein Paket,

womit man ganz viele tolle Datensachen machen kann,

wo es vorinstalliert ist. Also ich persönlich

hatte da nicht so die besten Erfahrungen mit, das war immer

sehr verwurschtelt mit den Paketen

und dann lief immer was nicht, wenn es irgendwie ein Update gab

von den neuesten Python-Versionen, die haben auch einen eigenen

Paketmanager, einen Conda 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, 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

Conda 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 alles

Eigentlich ist das alles ein bisschen furchtbar.

Man muss sagen, dass es schön wäre,

in einer idealen Welt hätte man das ja gerne,

dass man einen Paketmanager für alles verwendet.

Es gibt auch so ein bisschen die Utopie,

wird so ein bisschen gelebt bei NixOS.

Da versuchen Leute, das tatsächlich noch umzusetzen.

Oder eigentlich waren auch die Linux-Distributionen

mal so quasi gedacht,

dass man halt einen Paketmanager hat,

mit dem installiert man halt irgendwie alles,

was man irgendwie haben möchte.

es geht ja auch jetzt noch, wenn man jetzt ein Debian hat

beispielsweise, dann kann man auch ein 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 man muss,

es ist halt tricky, das zu kompilieren, da ist viel

Core-Transworks dabei. Das ist alles nicht so

einfach und

ja, überfordert möglicherweise halt

ein Debian-Meter auch so ein bisschen.

Also du würdest auch immer alle Pakete

über PIP installieren, oder?

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

haben wir nicht, also am schönsten wäre es,

wir hätten einen Paketmanager für alles.

Also zum Beispiel PIP oder deinen Distributionsmanager?

Nee, sowas wie ABT oder genau, oder

weiß nicht was dabei,

Yam für Red Hat gibt.

DNF ist mittlerweile, glaube ich,

auch bei Red Hat, 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.

Bei Python ist es halt

erst mal pip, so wie bei

Ruby sind das diese Ruby Games,

bei Perl ist es

Sepan, beziehungsweise, 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 yarn 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 Routefile-System installiert,

dann überschreiben die natürlich Sachen, die die Disposition

da reingeschrieben hat.

Überschreiben sich gegenseitig.

Alles nicht so schön.

Niemand hat darauf 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 versucht man das dann irgendwie

zu isolieren und installiert

Dinge nur in Environments.

Also in virtuellen Entwicklungen.

Virtuelle Umgebungen, genau.

Oder für seinen einen User. Also zum Beispiel pip install

Paketname minus minus User.

Wird halt das für den aktuellen Nutzer nur installieren?

Genau, das kann man auch machen.

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

Aber leider ist es sogar noch schlimmer.

Es ist jetzt nicht nur so, dass jeder Programmiersprache einen eigenen Paketmanager hat,

sondern es sieht so ein bisschen, also jedenfalls bei Python ist es leider so,

dass auch jede Community ihren eigenen Paketmanager nochmal hat.

Also die ganze Web-Community verwendet eigentlich überwiegend PIP,

während die ganze Data-Science-Community überwiegend Conda verwendet.

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

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.

Einfach eine Liste von Listen und dann quasi eine Liste von Spalten oder Zeilen.

Moment, NumPy, glaube ich.

Ja, ja, genau, aber 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, 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 NumPy unten drunter halt quasi,

weiß ich jetzt gar nicht, was man da mal spritzen möchte.

Ich muss mir jetzt gerade so auszumalen, wie das dann so aussieht in einem 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, Lapak, 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.

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 wenn man das einfach an C kommt,

kann man natürlich 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 dem Nampal liegen, halt machen.

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 dir einen Callback

oder so. Weil vor Schleifen gehen halt nicht mehr.

Das ist ein bisschen komisch,

aber ist halt dafür schnell.

Mir ist das 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 kaufen. Python ist ja immer

als langsam verschrien, aber wenn wir den auch schnell bekommen,

ja okay, dann machen wir vielleicht mal einen kleinen Umweg.

Genau, genau. Ja, kommen wir vielleicht

gleich noch zu, wenn es um die Mythen geht.

also das ist, man kann damit

auch sehr schnell Dinge tun und

dafür muss es halt auf Bibliotheken

basieren, die das halt auch schnell machen können und

für Scientific Computing und Zeugs ist

es halt vortragend 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?

Ja, was ich ein bisschen vernachlässige,

Genau, auch ein Bereich, der momentan sehr interessant

wird, ist so

Home-Automation-Zeug,

Smart Home. Ich glaube, der Raspberry Pi, der macht

ja ganz, ganz viel. Ja, genau, Raspberry Pi wird da

oft verwendet und überhaupt Raspberry Pi

und Python haben viel,

viele schöne Anwendungen,

da kann man viel drauf machen.

Home-Automation, du hast ja, glaube ich, ganz viele

schöne Sachen mit. Ja, ich habe auch einen Raspberry Pi

irgendwo im Schrank stehen, der zum Beispiel

Temperaturen ausliest, indem man,

ich habe so ein DVB-T-Modul da

reingesteckt, die gibt es jetzt irgendwie günstig, weil es gibt kein

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

Richtig, jetzt kann man die Dongle

kriegt man relativ willig

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

es gibt ein Software, das nennt sich Home Assistant

schicken, also das ist ein bisschen komplizierter.

Ja, da machen wir auch noch eine eigene Folge. 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ß nur nicht, wie ich den Wassertransport

automatisieren soll. Das ist ein bisschen gefährlich.

Eine Pumpe irgendwie und dann einmal einfach

unabsprichtversichert.

Ja, wäre eine Idee

tatsächlich vielleicht.

Genau.

Ja, aber in dem Bereich ist Python halt auch,

glaube ich, 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 MicroPython zum Beispiel drauf, sodass man da halt...

Nächste Folge. Ja, genau.

Das heißt, man kann auch da Python

drauf laufen lassen und dann

irgendwie Sensordaten damit schon irgendwas machen.

Da muss man aber 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, also was noch dazu kommt, vielleicht so Rapid

Prototyping erstmal nochmal als Basis wird

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 Sprache vergleicht, 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 lauffähiges Programm,

was wenigstens so grob das tut,

was es sollte später.

Dazu würdest du sagen,

ist noch so einer der großen Vorteile

der Sprache, wo man jetzt von außen drauf guckt.

Wir sind jetzt nicht so 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, mit denen man auch diese ganzen

Dinge tun kann.

Also Python ist halt,

würde ich sagen, gehört so zur

Familie der

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

Sozusagen

Dinge können ihren Typ

ändern oder man weiß nicht, was sie sind

sozusagen von Anfang an.

Das ist in Python auch so.

Aber in Python ist halt

streng getypt.

Auch dynamisch und streng.

Das heißt, wenn ich jetzt sage,

irgendwie eine Zahl plus

irgendwie ein String oder so,

dann kriege ich bei Python

dann halt ein Type Error, also

ein Fehler.

Also ein Fehler.

Da haut mir Python halt auf die Finger,

während in PHP oder in JavaScript

passiert dann halt irgendwas.

Was passiert denn da?

Oder ist das dunkle Magie wahrscheinlich?

Es ist eher dunkel und

man weiß nicht so genau, was dann passiert.

Es kommen die komischsten Sachen, aber es gibt einen schönen

Vortrag

für JavaScript,

das mal jemand, es ist ein bisschen veraltet,

aber hat das mal jemand

aufgeschrieben. Ich glaube, wenn man danach sucht

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-String

und dann kommen halt die seltsamsten Dinge dabei raus.

Oder der Server hüpft und blinkt und

am Schluss kommen irgendwelche Zeichenkenten dabei raus und

Batman erscheint. Also es ist wirklich,

man muss aufpassen, was 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 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,

also ich finde, was man über Python sagen kann,

es macht halt die richtigen Trade-offs.

Also es ist halt immer, es ist halt so eine Sache.

möchte man

jetzt, das hat ja natürlich auch Vorteile,

man kann Dinge

vielleicht abkürzen oder so, wenn man das

schwach getypt, 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 Linter 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, also aber

das Schöne ist halt, das ist halt optional.

Man kann das da ranschreiben. Also klar,

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,

was einen anderen Typ. Das geht da halt gar nicht.

Und das kann auch nicht sein, dass

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

dafür. 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 bringt auf jeden Fall

einen interessanten Trade-Off, weil als Anfänger würde ich

mir jetzt erstmal so denken, dynamisch

klingt ja voll cool, da kann das immer was Verschiedenes sein

und da 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 ja, das

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

PyCharm und so können das möglicherweise auch schon.

Die kann einem dann dabei helfen und dann auch

sagen, wenn irgendwas nicht geht.

Ich glaube also zum Beispiel

in Listen kann man auch verschiedene Datentypen

benutzen, es sei denn, man benutzt erst NumPyArrays, wo das

dann auch wieder fest ist. Aber ja, das glaube ich

auch ganz interessant, weil es 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

einer dieser Geschichten, wo

statisch getypte Sprachen

große Schwierigkeiten mit haben oder

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

ist inzwischen auch in Java angekommen

und man kann da auch so Sachen machen,

aber das ist alles dann nicht mehr so richtig

einfach und ein

Dingen, 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 drin sein.

Wenn das halt nicht geht, dann

dann muss man sich halt so Patterns

überlegen, wie man Dinge tun kann.

Für viele Situationen kann man

das dann halt nicht einfach so hinschreiben, was man machen möchte,

sondern dann muss man halt, dann gibt es

ein ganzes Gang-of-Four-Buch

irgendwie.

Bitte was? Das ist ein ganz bekanntes Buch

von, naja, wer ist das?

Das wird immer Gang-of-Four-Buch

genannt.

Ja, das musst du unbedingt auch in die Shownotes packen.

Ja, ich glaube, das Ding heißt auch immer Design Patterns

oder so. Und da 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 brauche da gar keinen Pattern.

In Python kann ich das einfach so hinschreiben.

Da muss ich mir kein kompliziertes

das Ding ausdenken, mit dem ich halt irgendwie da jetzt

Architektur-Ding, mit dem ich da mit diesem Problem fertig werde,

weil ich habe 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

dieses Buch wurde halt gefeiert als

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.

Ja, also

Also da würde ich sagen, ist halt auch eine der Stärken von Python,

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 macht das Leben schon irgendwie leichter.

Ja, das wäre so der Unterschied statisch getypt, dynamisch getypt.

Genau, den strengen Sprach hatten wir jetzt auch schon im Vergleich zu den anderen Programmiersprachen.

Was wir auch noch haben, ist quasi binär kompiliert.

Das hatten wir aber auch eben schon ein bisschen abgehandelt.

Dann gibt es natürlich Sprachen, in denen man das Memory Management selber macht.

So C zum Beispiel.

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

Ja, also

genau, also

man alluziert 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.

Oder ja,

wenn man Dinge freigibt, die man

die eigentlich immer noch brauchen,

dann passieren schreckliche Dinge.

Und wie löst man das in Python?

In Python hat man damit nichts zu tun.

Das ist sozusagen

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

wenn man einfach sich in Python

bewegt, dann hat man damit eigentlich nichts zu tun,

weil das passiert dann automatisch.

Python verwendet da ein System, das nennt sich

Reference-Counting.

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

haben einen Garbage-Collector.

Wie Python?

Ja, also Python hat auch einen Garbage-Collector,

aber ja,

es ist ein bisschen kompliziert leider.

Aber hauptsächlich ist es ein Python

Reference-Counting, sozusagen.

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 irgendwo eine neue Reference entsteht,

dann wird der Reference-Counter hochgezählt

und irgendwie ansonsten,

wenn eine Reference verschwindet, gelöscht wird,

dann wird es runtergezählt und wenn es bei 0 ankommen wird,

wird das Objekt abgeräumt.

Und

das hat

den großen Vorteil,

es ist ziemlich schnell zur Laufzeit

und

es ist

sozusagen auch

sehr einfach, also kann nicht viel schief gehen.

Es sorgt für

vorhersagbare Latenzen.

Es hat aber auch einen großen Nachteil.

Okay.

Der große Nachteil ist,

ja, man kann

dann nicht mehr Paralleldinge machen.

Oh Gott, oh Gott, oh Gott. Also auf unterschiedlichen Prozessoren.

Das geht im Grunde nicht mehr.

Also das könnte man tun, da muss man halt

wenn man es naiv

machen wollte, müsste man dann für jede Operation,

die jetzt irgendwie so ein Reference-Counter

hoch oder runter zählt, da müsste man irgendwie

so einen Lock drauf machen und sagen, so,

jetzt mal alle stopp, wir erhöhen

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

Ich glaube, Leute haben irgendwie lange daran gefeilt,

sind jetzt auf Faktor 20 oder so runter,

wo man gar nicht gedacht hätte, dass es überhaupt möglich wäre.

Das heißt, du brauchst 20 Kerne, damit du dann den einen Kern...

Die Performance von einem Kern hinfickst, genau.

Das ist natürlich irgendwie nicht so richtig effizient.

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

Und dafür gibt es halt bei Python auch den Global Interpreter Log.

Den bitte was?

Ja, GIL oder Global Interpreter Log.

Das ist sozusagen ein Ding, was dafür sorgt,

dass quasi ein Python-Prozess nur auf einer CPU läuft

und nicht ein Python-Prozess auf mehreren CPUs laufen kann.

Das ist halt so.

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

Java hat einen Garbage-Collector und hat dann dieses Problem nicht.

Das kann dann halt auf mehreren Prozessoren laufen, problemlos.

Oder, naja, problemlos, aber geht.

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

Dafür ist dieser Garbage-Collector.

Das heißt, auf einmal gibt es eine Pause.

Nee, der Müllteil ist voll.

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

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

Und das bedeutet halt, wenn man einen Server laufen hat,

dann kann es halt sein, dass man irgendwie plötzlich,

alle Requests sind super schnell und dann plötzlich einer dauert so lange.

Also jetzt, um bei dem Müllauto Beispiel zu bleiben,

kann man nicht einfach messen, wie voll der Müllcontainer ist

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

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 der Müll weggebracht werden muss,

musst du allen sagen, so, jetzt mal stopp,

jetzt muss erst mal der Müll weggebracht werden.

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

Ja, und

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? Hatte 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 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 kannst du halt

irgendwie Sachen auf mehrere Prozessoren verteilen, aber du hast halt den

Nachteil, dass deine Latenz so ein bisschen

unvorhersagbar wird.

Ja, das ist halt blöd.

Und ja, das

sind halt,

man kann sich halt überlegen, was man irgendwie

lieber mag, sozusagen. Und auch

da finde ich, dass Python dann eine ganz

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

Referenzen irgendwie, also wenn das

eine 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 sich in den Schwanz.

dann werden die durch Reference-Counting nicht weggeräumt

und dann muss auch Python ab und zu mal

einen Garbage-Collector anschmeißen, um solche Sachen zu finden und dann

rauszuwerfen. Aber den Garbage-Collector kriegt man

bei Python mit so etwas wie Import-GC dann?

Ja, genau.

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