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.
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 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,
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.
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.
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, 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
das wäre natürlich, deswegen hab ich das auch ganz lange gemacht
aber tatsächlich ist es so, dass heutzutage
hat man diese Anwendungsfälle
fast nicht mehr und, äh
die Monitore kann man meistens besser
coden, oder? Also es sieht besser aus auf einem eigenen
Monitor, oder? Ja, es ist
vor allen Dingen auch, äh, es gibt halt viele Fälle, wo es
halt schwierig wird, wenn man dann immer quasi nach
der, nach der Anzahl Zeilen umbrechen
äh, Zeichen umbrechen muss
dann muss man halt komisch rumformatieren
äh, und dann lieber
schön, und dann lieber schön, ja, und das
bricht halt dann diese, diese Begrenzung
so gerade bei Tests, finde ich, ist es sehr schwer, das
einzuhalten, weil oft muss man halt lange
Testnamen haben
oder, wenn das irgendwie sprechend sein soll
und gut lesbar sein soll, dann, äh
im gleichen Namen noch umgebrochen, uh, ja
ja, genau, dann kann, kann man eigentlich
nicht mehr umbrechen und dann wird's halt einfach lang
also, daher bin ich jetzt, ich, ich
weiß nicht, ich glaub, 130, äh, ich weiß nicht
noch, wie die, wie die konkrete Zahl ist
äh, vielleicht rede ich auch Unsinn, ich benutze das halt
ich formatiere meinen Code auch mit Black, also
ich nehme das, was Black sagt
und kümmere mich nicht mehr drum, ich hoffe, die haben das
irgendwie gut überlegt und, ja
ähm
genau, was haben wir noch, äh
ja, genau, Fehler sollten nicht einfach
so, äh, still, äh
weggeworfen werden, sondern sollten immer
sichtbar sein. Also wir haben ja auch
ein Python Assertion oder sowas, ich weiß nicht, ist das
ein besonderes Feature oder gibt's das bei Ansprachen auch
alles? Assert, das ist ein, ja, das ist
ein, also, gut, das ist ein Keyword der Sprache, das, äh
mit dem man halt, äh, überprüfen
kann, ob irgendeine Bedingung oder
irgendwas wahr ist, was sein soll, und wenn's halt
nicht so ist, dann, äh, wirft
das halt einen Fehler, ja
kann man, kann man einen guten Test schreiben
ja
äh
genau, ja
Fehler sollten irgendwie nie still weggeworfen
werden, außer man bringt sie zum Schweigen
irgendwie explizit
äh, ja, wenn man, wenn
man irgendwie, äh, mehrere Dinge zur Auswahl
hat, ja, äh
sollte man irgendwie der Versuchung
widerstehen, irgendwie einfach zu raten
äh, es sollte nur ein und, äh
möglichst nur
einen, einen einzigen, äh
äh, offensichtlichen Weg geben
wie man Dinge, äh, tun, äh
tun sollte, und das ist natürlich ganz, ganz klar
irgendwie ein Ding gegen Perl, weil Perl ist halt
das Gegenteil davon, es gibt irgendwie
Perl ist auch, ich weiß nicht, da gibt's auch einen, einen
ja, du kannst es halt irgendwie
so machen, es gibt viele Wege zum
Ziel, ne, du kannst es halt so machen, wie es dir am besten
gefällt, was halt dann in der Praxis dummerweise
dazu führt, dass es jeder irgendwie anders macht, und
äh, das, äh, die Lesbarkeit
natürlich extrem, weil, weil jeder schreibt
dann halt sozusagen sein, sein Perl-Idiom
und, ähm, man kann halt nicht mehr
so gut, also bei, bei manchen Leuten war es
so, wenn man das nicht angeguckt hat, dann
äh, äh
was, was, was ist das überhaupt, es gibt
ich meine, teilweise ist es sehr schön, ich hab auch mal
ich hab das mal, äh, äh
ein Buch gelesen von, von, äh
äh, Damien Conway, ich weiß nicht genau, Higher Order
Perl oder sowas, äh, auch ganz
viele verrückte Sachen gemacht, also was hab ich denn mit Begeisterung
verwendet, und fand das total toll, was man alles
für komplexe Geschichten irgendwie da in wenig
äh, Zeichen irgendwie unterbringen kann
aber ich glaub, äh, ich würd das heute
wahrscheinlich nicht mehr lesen können, und meine Kollegen damals
oder kurz danach konnten das wahrscheinlich auch nicht mehr
lesen. Oder du selber, ich weiß nicht, zwei Stunden
später. Ja, ja, zwei Stunden später ist halt dann vorbei
und das ist, das ist nicht ganz so, es ist nicht
optimal, das ist irgendwie, da ist, da kann man noch was
verbessern. Zu lange danach gearbeitet, dann steht man morgens wieder
auf und dann so, oh, was hab ich jetzt mal da gemacht, ähm
äh, ähm
ja, also, das, äh
ähm, ja, heutzutage
Also dokumentiert immer schön euren Code, in Python könnt ihr
damit sogar Doctests machen, ne, das heißt, ihr testet
dann selber auch das, was ihr dokumentiert
Ja, weiß ich aber nicht, ob das so ein schlauer, also
ob das so eine gute Idee ist, kann man machen
Nein, macht man nicht. Ja, ich
würde eher explizite Tests
schreiben, so, und ich würde auch PyTest nehmen
es gibt halt auch das eingebaute
Test-Framework, äh, von, von
Python, das sich stark an
äh, JUnit, äh, glaub ich
einem Unit-Testing von, von Java irgendwie orientiert
hat, äh, ich weiß gar nicht, wie das heißt
und, äh,
das ist komisch, weil es ist halt nicht so richtig
Pythonisch, weil
es ist halt halt so, die Dinge wie, äh,
Konventionen, per Konvention sind
halt die Methodennamen CamelCase
und nicht mit Underscore, normalerweise
Underscore, und da ist aber CamelCase
so wie in Java, und das ist halt, sieht
komisch aus, äh,
und diverse andere Dinge sind auch eigenartig
das fühlt sich oft eher an, als würde man
Java schreiben als Python, und das ist halt eigentlich nicht schön
und deswegen würde ich eben nicht das
eingebaute Ding nehmen, nicht das eingebaute Unit-Test-Framework
sondern, wobei, wobei von den Features her
die können quasi das gleiche
Aber die Dock-Tests ist ja jetzt nicht, äh, oder, oder?
Dock-Tests weiß ich gar nicht
Weil die Dock-Tests ja einfach in den Dokumentationen dann irgendwie die Funktionen testen
Ich, ich weiß, äh, weiß gar nicht
ob das, ähm
wie die ausgeführt werden, oder welche Testrunner
die dann halt, äh, äh, ausführt
Wenn das, wenn man den einstellen kann oder so, das kann
auch alles gut, aber
äh, ich, ich würde halt
eher als Testrunner eigentlich immer eher PyTest verwenden
Ja, ja, ich glaube PyTest
nimmt auch die Dock-Tester mit an, oder so
Das, das kann gut sein, das, ich hab das, ich hab noch nie
Dock-Test, äh, aber das ist auch alles nur geraten, ähm
Keine Ahnung, muss man sich mal, muss man sich mal angucken
Vielleicht ist auch alles gut
Aber ich würde auf jeden Fall, wenn man, das ist halt auch so
eine unoffensichtliche Geschichte, ne, wenn man vielleicht anfängt
dann denkt man sich so, ach, ich nehme jetzt das eingebaute Unit-Test
Framework
Implementation ist hard to explain
It's a bad idea, deswegen
send off, also, ihr seht schon
Wenn wir jetzt irgendwie anfangen rumzustammeln, dann ist das alles
totale Grütze, was sie da gebaut haben, natürlich, ähm
Äh, ja
Ja, now is better than
never, ja
Ja, also das Do-It, ne, so ein bisschen das Nike-Prinzip
Also einfach anfangen, machen, Prototyping
Ob schon
Niemals
Vielleicht, äh, oft besser
sein könnte als genau jetzt
Ja, man weiß
Wenn man das so genau
Wenn die Implementation schlecht zu erklären ist
Äh, es ist eine schlechte Idee
Wenn die Implementation leicht zu erklären
ist, könnte es sein, das ist eine gute Idee
Ist, aber
Ja
Ja, Namespace ist eine total tolle Idee
Sollte man irgendwie mehr von machen, ja
Ja, das ist
Was ist das an Namespace? Vielleicht musst du das nochmal kurz sagen
Ähm
Sozusagen
ein, ein, ein, ja, wie kann man das generell
Also, äh
Korrekt übersetzen wir ja, der Namentraum, also wenn man
sein, äh, Variable genauso
nennt wie die Nachbarvariable, dann ist es relativ
schwierig, die dann irgendwann auseinander zu halten, weil
wenn man das eine Kind rufkommt, entweder beide oder
nur eins von beiden, oder gar nichts mehr, oder
Und dann kann man das mit einem Namensraum-Präfixen
sozusagen, in dem dann halt ein Name eindeutig ist
Was so ein bisschen, ich weiß nicht, ob da ist
eine leichte Ironie, fürchte ich, drin, weil
bei beiden ist das halt nicht so schön getrennt, und wenn man jetzt
zum Beispiel vom irgendein
Modul-Importstern sagt, dann
überschreibt einem das gnadenlos halt
irgendwie Dinge, die man
selber definiert hat vielleicht, oder aus
anderen Modulen oder so, die halt in dem
Man kann auch übrigens die ganze Standardbibliothek überschreiben, wenn man
einfach viel Namen verwendet. Ja, ja, kann man
alles machen, es gibt auch Leute, die dann, um das zu
gehen, sagen, die dann irgendwie import dieses
vom das
als irgendwie was ganz anderes,
damit sie auf keinen Fall irgendwie sich Dinge
überschreiben und so
Ja, das ist alles so ein bisschen
Aber
im Grunde gibt es natürlich schon
Namensräume in Python, und
ja, das funktioniert
eigentlich auch ganz gut
Ja
Wir sehen, auf Python
haben wir jetzt schon ein bisschen den Zuhörern
auch noch nähergebracht, also was man darunter so ein bisschen
versteht, wie man, ich sag mal, ganz
besonders entspannenden Python-Code
schreiben, wie man da richtig rangeht, also
tatsächlich müsst ihr es nicht zu komplex machen, ich glaube, wenn man
die einfache Lösung ist besser, keep it
short and simple, das ist
glaube ich immer eine gute Idee, auch
unabhängig vom Python, aber
dadurch wird es halt sehr lesbar und sehr
korrigierbar, ihr könnt auch sehr gut damit kooperativ
arbeiten mit anderen, weil ihr, glaube ich, relativ
schnell verstehen werdet, was sie da denn so getan
haben, ich meine, auch da gibt es Ausnahmen, aber
das kann auch sein, dass das die
äh
ich weiß nicht, ob es immer gut ist, wenn man schnell versteht, was andere da getan haben
das könnte auch so, äh
ja
wie das bei Douglas Adams oder so
irgendwie, als der Babelfisch eingeführt wurde
und alle sich plötzlich verstanden haben, dass es gab den
schlimmsten Krieg ever, oder
keine Ahnung, irgendwie so
Ja, das ist immer jetzt hier, das ist ein paar lustige Sachen, die ich letztens gesehen habe
irgendwie mit Lesen von Gesichtsmuskulatur
und sowas, dann die Worte deines
inneren Gedankens aufschreiben kann und so, das ist
ja
Naja
Ja
Alter Ego heißt das Ding
Ach, okay, ja, da wird auch noch eine Menge
interessante, werden noch eine Menge interessante
Dinge passieren, glaube ich
Ja, aber ansonsten, ich weiß nicht genau, sind wir
so ein bisschen durch, ne, mit der Einführung
Ja, ich würde das tatsächlich sagen, wir sind langsam am Ende der ersten
Folge angekommen, also wir haben es
quasi fast geschafft, also was haben wir jetzt gerade schon gemacht
wir haben uns dann auf Python kennengelernt, haben uns
ein bisschen an die Einführungstools gegeben
so ein bisschen die Features der Sprache uns
angeschaut, irgendwie
Ja, ja, wie kann man einen Einstieg
finden, wofür wird das eingesetzt
Also falls ihr Fragen habt, wie gesagt
schreibt uns gerne an unsere E-Mail-Adresse
da kriegt ihr alles nochmal
erklärt, ihr filmt mit Sicherheit auch ganz viel im Internet
in Tutorials, es gibt ja unzählige
schöne, spannende Seiten
die Suchbegriffe werdet ihr bestimmt schon finden dafür
Ja, genau, dann
würde ich sagen, in den
nächsten Episoden gehen wir dann halt mal so
oder da machen wir halt so irgendwie ein Thema
pro Episode und gucken einfach mal, dass wir
das ein bisschen näher beleuchten. Genau, nicht so der ganz allgemeine
Schwank, sondern vielleicht tatsächlich irgendwie
was Spezielles, irgendwie eine Modul-Juridik
oder eine Technik oder
irgendwie eins der Topics, die noch spannend sind
Wenn ihr Vorschläge habt, wenn ihr irgendwas Besonderes hören wollt
kommt gerne, sagt da von Voss
der, ja, Jochen wird euch bestimmt
was dazu erzählen können
und ich stelle Ihnen blöde Fragen, also so ist das
Ja, und vielleicht beschließen wir noch
ein bisschen mit Veranstaltungshinweisen, wir sind ja hier
Wir sind ja jetzt in Düsseldorf, also
wenn ihr selber Veranstaltungshinweise habt
dann sagt doch bitte gerne Bescheid
dann können wir auch eure Veranstaltungen jetzt im
deutschsprachigen Raum gerne promoten und hier vorstehen
Bei uns ist nächste Woche
nächstes Wochenende jetzt hier Python Sprint
Das ist immer eine tolle Gelegenheit, so ein bisschen
Leute kennenzulernen, ich glaube, der ist diesmal schon voll
und auch die Wartezeit ist schon voll, aber er ist glaube ich zweimal im Jahr
gibt es bei Meetup oder
bei PyDDF, also die Düsseldorfer
PyDDF.de, super tolle Leute, immer ganz
viele entspannende Vorträge
Schaut euch das auch einfach mal an und
ja, tatsächlich
zweimal im Jahr, also schaut einfach
mal vorbei. Ja, also wenn ihr
die Events in eurer Nähe promotet, schickt ihr auch
eine E-Mail einfach an hallo.pythonpodcast.de
Ja
Ansonsten, genau, was faszinierend ist, es gibt einmal
die Python User Group
Düsseldorf, PyDDF, die halt auch diese
Sprints organisiert. Es gibt
einen Python-Foo, das ist
im lokalen Düsseldorf
Microspace in Chaosdorf, das ist einmal
wöchentlich, ist deutlich kleiner
Es sind mehr so
immer die gleichen Leute, die da hingehen
Die ersten zwei Mal im Monat ist glaube ich
für Anfänger und die letzten zwei Mal ist
Ja
Aber ich finde, es ist auch ganz toll,
irgendwie sollte man
sich nicht von abschränken lassen,
das ist halt so ein bisschen, dass man so reinkommt und denkt so
Ist die Veranstaltung jetzt
oder ist
es gerade irgendwas anderes?
Naja, das sind alles sehr nette Leute
Dann, aber genau, vielleicht
wenn man gerade mit Leuten mal persönlich irgendwie ein bisschen mehr
reden will, ist das vielleicht ein bisschen besser, weil
PyDDF ist eher vortragsorientiert
und immer ein bisschen etwas größerer Rahmen
Dann gibt es
das Data Science Meetup in Düsseldorf
das ist auch mal sehr gut besucht
wo es häufig um Python-Themen
auch geht
QuantFinance bei Jesus Statistik
für fortgeschrittene Themen auch
Genau, und dann gibt es
die Python User Group Köln
einmal im Monat
gibt es da ein Treffen, das ist auch
das ist auch immer meistens so 20-30
Leute und
es gibt immer interessante Vorträge, danach geht man
irgendwo essen
Ach, das ist bei PyDDF auch so
Hm
Ja, es ist also mehr im Umfeld, wie gesagt, wenn ihr
irgendwo aus, weiß ich nicht, schieß mich tot, Wien
München, von der Ostsee
in der Uckermark, irgendwas findet, dann sagt Bescheid
Ja
Da stehen wir hier gerne auch vor
Ja, ich kann nur sagen, Jochen, vielen Dank
Ja, danke Dominik
Ein bisschen schlauer geworden
Tja, kann's gehen
Ich hoffe, die Hörer haben auch ein bisschen Spaß gehabt
Ja, dann bis zur nächsten Folge
Bis zum nächsten Mal
Tschö