Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python Podcast, allererste Folge, allererste Episode.
Wir wollen euch heute ein bisschen fügen und folgende Fragen beantworten.
Was machen wir eigentlich und warum?
Wie finde ich einen Einstieg in Python?
Also, wenn ich Anfänger bin, wie kann ich damit anfangen?
Und geben ein paar Anfängertipps.
Und dann wollen wir noch ein bisschen erklären, wie Python funktioniert, ein paar Mythen über Python klären und so weiter.
Wenn ihr Fragen, Anmerkungen zu dem Podcast habt, Kommentare, alles was gut ist, was schlecht ist, dann sendet doch einfach eine E-Mail an hallo-at-python-podcast.de.
Und ja, Links und zusätzliche Shownotes zur Sendung findet ihr natürlich in den Shownotes.
Ja, was machen wir eigentlich? Kleine Einführung?
Ja genau, vielleicht können wir uns einfach kurz vorstellen oder so.
Ja, also wir sind auf jeden Fall aus Düsseldorf, aus dem wunderschönen Wintergarten von Jochen, den ihr gerade kurz gehört habt.
Ja.
Wer sind wir denn? Hallo Jochen.
Hallo Dominik, genau, also ja, mein Name ist Jochen,
die wirklich wunderschöne Anmoderation gerade kam von Dominik.
Und genau, ja, wir benutzen beide Python und ich höre auch sehr viele Podcasts
und im englischsprachigen Raum gibt es halt durchaus einige ganz gute Podcasts,
die man da hören kann, aber ja, zur deutschsprachigen gab es immer mal wieder Versuche,
Aber letztlich momentan, soweit ich weiß, jedenfalls kein, der kontinuierlich aktualisiert wird.
Und ja, da dachte ich, na gut, wenn es niemand macht, dann kann man das ja vielleicht einfach selbst mal probieren.
Und ja, dann habe ich mich so ein bisschen herumgefragt, ob es Leute gibt, die das vielleicht auch gerne machen würden.
Und ja, so sind wir dann zusammengekommen.
Wie kamst du zu Python, Junge?
Ja, das ist jetzt auch schon eine Weile her.
irgendwann so 2000, Anfang der Nullerjahre sozusagen.
Ich war ursprünglich da eher so auf der Perl-Seite
und dann war aber die, ich habe damals bei Web.de gearbeitet
und die Firmensprache da war dann halt aber Python
und dann wurde mir nahegelegt,
auch ein paar der Dinge, die ich da gemacht habe,
irgendwie doch eher in Python zu machen als in Perl
und dann habe ich das erst so ein bisschen gedacht,
na gut, ob ich das wirklich toll finde,
aber relativ schnell war ich da ziemlich begeistert von Python
und mache seitdem eigentlich nur noch Python und kein Pal mehr.
Du bist schon ein ziemlich alter Hase, wenn ich das so sage.
Ja, alter Sack, ja.
Genau, und in unterschiedlichen Bereichen
habe ich das jetzt schon so verwendet.
Und daher, ja, denke ich, ist es vielleicht auch ganz...
Kann ich da auch so ein bisschen was zu erzählen,
was da so ein Python alles machen kann.
Ja, deswegen bist du da.
Also ich gehe davon aus, dass du mir alles erklären kannst, was ich an tollen Fragen habe.
Ich möchte nämlich noch jede Menge wissen.
Genau, und wie bist du zu Falken gekommen?
Ja, ich bin ein ziemlicher Rookie noch.
Ich bin jetzt insgesamt anderthalb Jahre irgendwie bei Python dabei.
Und interessiere mich vor allem für, ach, vielleicht ein paar Buzzwords, Data Science und Digitalisierung.
Was man damit so machen kann.
Ich habe zwar auch schon damals in der Schule angefangen mit ein bisschen Programmieren und war seit 96 in der Internet-AG.
Das war damals ganz besonders fancy und habe Webseiten da gebastelt und so ein Krams.
Habe dann aber einen ziemlich längeren Umweg gemacht über die Volkswirtschaftslehre,
bis ich dann tatsächlich vor anderthalb Jahren mich dazu entschlossen habe,
irgendwie nochmal einen ganz neuen Weg zu gehen.
Ein Umdrehen von vorne beginnen und das zu tun, was mir wirklich am Herzen liegt.
Eigentlich wollte ich nur ein paar Daten analysieren und bin dann über ein Python-Tutorial gestolpert.
Nach ungefähr 20 Minuten hat es mich dann irgendwie ziemlich vom Hocker gehauen und erwischt
und ich wusste, dass es genau das ist, was ich in Zukunft machen will.
Und so bin ich bei Python gelandet.
Ja, von einfach mal nur ein paar Daten analysieren
zu, ja, neue berufliche quasi Herausforderungen.
Oh, da klopft jemand an die Tür.
Das hat ein Spielzeug in der Hand.
Mhm.
Nun gut, ich hoffe, das stört nicht so weiter.
Ja, das ist auf jeden Fall ein schneller Einstieg gewesen,
wenn das nach 20 Minuten schon geschnackelt hat.
Wäre jetzt ein bisschen länger gedauert, aber
ja, das ist auf jeden Fall
eine gute Sache, glaube ich. Das war wirklich so. Ich kam
da rein, hab den ersten Code geschrieben und hab gedacht,
ja, genau, das wollte ich dann machen.
Stimmt. Hammer. Also
liegt bestimmt auch vielleicht an der Einfachheit der Sprache, aber
da kommen wir vielleicht ein bisschen später zu, was für
Features Python alle hat.
Ja, vielleicht fangen wir noch mal an.
Warum machen wir das eigentlich? Für wen ist denn dieser Podcast
genau? Was glaubst du? Für eigentlich jede, die sich
für Python interessiert?
Ja, ich denke schon.
Das ist halt auch so
so ein Ding, dass Python momentan halt
sehr viel an Popularität gewinnt.
Also ich meine, das hat es schon immer getan, also es war
schon immer recht populär,
aber in letzter Zeit, gerade
eben über Data Science
und verwandte
Themen, Machine Learning, Deep Learning,
Dinge, die halt auch sonst sehr stark gehypt
werden, ist Python halt sehr, sehr
groß geworden und mittlerweile hat es
halt irgendwie Ausmaße
angenommen, die
dazu führen,
dass es jetzt eine ganze Menge Leute gibt, die das gerne
lernen würden oder sich dafür interessieren
und aber wenig
Angebote sozusagen
diese ganzen Leute irgendwie abzuholen
und ich denke, da können wir auf jeden Fall
eine Menge
Hörer ansprechen
sozusagen
aber ich würde das nicht
unbedingt auf Anfänger beschränken, sondern einfach mal
so quer durch alle
größeren Themen oder so, die es gibt
wir hatten uns ja auch schon so ein bisschen Gedanken zu gemacht, was man da alles mal
worüber man, über welche Dinge man mal
so eine Sendung machen könnte und da haben wir
auf jeden Fall genug Stoff zu senden und da können wir auch gerne mal so richtig fies
ins Detail gehen.
Ja, genau.
Also ich glaube, bevor wir euch erzählen, was wir heute denn genau so machen, wir haben
ja einen kleinen Einstieg schon gegeben, gibt es tatsächlich diese ganzen vielfältigen
Themen in Python und wir wollen uns tatsächlich in mehreren Episoden euch das ganz Interessante
mal so ein bisschen berichten über Django, über Datenbanken, über Python Performance,
über Machine Learning und ein bisschen Data Science, MicroPython.
Es gibt ziemlich einiges, was wir jetzt hier auf dem Zettel haben.
Ihr könnt also auch ein bisschen gespannt sein, was wir jetzt auch so machen.
Ja, was machen wir heute?
Das ist der Einstieg in Python.
Genau, einfach mal so eine Übersicht.
Genau, und dazu haben wir vielleicht erst mal ein paar kleine Fakten über die Geschichte.
Dann kann Jochen bestimmt noch viel mehr zu erzählen als ich.
Aber soweit ich weiß, hat Guido van Rossum die Sprache entwickelt in den frühen 90ern.
Und zwar aus Amsterdam das herausentwickelt.
Ja, also das ist schon gute, wie lange?
Fast 30 Jahre alt tatsächlich.
Würde man gar nicht denken.
Python 3, das wir alle nutzen, ist seit 2008.
Und falls irgendwelche Nachfragen kommen, ja, wir finden nur noch Python 3.
Ich glaube, das hat sich mittlerweile so eingebürgert.
Die neueste Version ist jetzt erst im Oktober erschienen, 3.7.1.
Und für nächsten Herbst ist, glaube ich, 3.8. geplant.
Also wir sind im Jahr 2018 für alle Menschen, die das irgendwann sparen.
Ja, also Jochen, im Laufe der Jahre hat sich ziemlich viel getan in der Sprache, oder?
Ja, wobei erstaunlich viele Dinge auch recht ähnlich geblieben sind.
Also ich meine, das ist halt auch möglicherweise einer der Unterschiede zu Sprachen wie,
jetzt nehmen wir mal so JavaScript oder so, wo sich halt in letzter Zeit sehr viel getan hat.
Und man dann immer, also ich mache in letzter Zeit auch irgendwie ganz schön viel JavaScript und oft muss ich dann, wenn ich jetzt irgendwas mache, so wie iteriert man denn jetzt nochmal über irgendwie quasi die Keys und die Values irgendwie in einem Hash oder so, dann, wenn man danach guckt, dann findet man halt zu jedem Jahr quasi und zu jeder neuen ECMAScript-Version eine andere Art, wie man das am besten jetzt tun sollte.
Und da ist Python eigentlich sehr, sehr stabil geblieben.
Das ist heute noch, ja gut, da haben sich auch an der Stelle
hat sich auch tatsächlich was geändert, aber sehr moderat
und mehr oder weniger so vorschleifend.
Das ist halt von Anfang an so, wie es jetzt heute auch noch ist.
Also es hat sich seit 30 Jahren im Grunde nicht großartig geändert,
wobei es da auch nicht so wirklich Bedarf gibt für eine Änderung,
weil es war einfach von Anfang an, hat es quasi gepasst.
Aber Antupa implementiert.
Ja, ich glaube, ja genau, 1991 ist das irgendwie gestartet und ich weiß gar nicht, ob ich da so wahnsinnig viel zu erzählen kann, weil damals war ich auch noch nicht dabei.
Das habe ich auch alles nicht so richtig auf dem Schirm, was da passiert ist.
Ich habe irgendwann angefangen, also die erste Python-Version, an die ich mich erinnern kann, mit der ich irgendwie Dinge gemacht habe, war so, glaube ich, 1.5.2 oder so.
Das muss irgendwann Ende der 90er gewesen sein.
Da habe ich aber kaum mit Python, also da habe ich nicht wirklich Python gemacht, um Python zu programmieren, sondern ich habe es halt verwendet in irgendwelchen Skripten und so.
oder irgendwelche Skripte angepasst und dann später so wirklich angefangen,
damit größere Dinge zu programmieren, habe ich dann mit Python 2.1 oder so.
Das war so die Version, in der ich die erste größere Geschichte geschrieben habe.
Was würdest du sagen, war so der größte Unterschied zu heute?
Der Umfang der Standard-Bibliothek oder?
Ja, natürlich, also da ist einiges dazugekommen.
Aber das ist gar nicht so...
Ja, so diverse Sprachfeatures, also Generatoren,
ich glaube, die kamen irgendwie mit 2.2 oder so.
Das ist heute doch etwas, was man viel mehr benutzt,
als man es damals getan hat.
Überhaupt diverse Keywords yield.
Ja, das stimmt, aber das ist auch schon relativ lange da.
Ich weiß nicht, wann 2.2 rauskam.
Müsste irgendwann 2002, 2003 gewesen sein oder so.
was heute eine große Rolle spielt.
Und damals war das halt alles noch gar nicht da.
Es ist alles, was irgendwie mit Async.io oder irgendwie, ja.
Wann kam das anfangen? Version 3 erst oder schon 2?
Nee, die Syntax dafür, also das ist jetzt erst in 3.5, glaube ich, mit dazugekommen.
Und es hat sich auch noch was zu 3.6 geändert.
Gab es da vorher ein externes Modul für?
Ja, es gab schon immer irgendwie externe Module,
mit denen man solche Dinge machen konnte.
sowas wie Twisted oder G-Event
habe ich auch eine ganze Zeit lang
verwendet, ist auch toll, aber das Problem ist,
dass man ja quasi,
wenn man dann auf eine dieser Bibliotheken aufsetzt,
halt in seiner eigenen Welt mehr oder weniger
gefangen ist und wenn jetzt jemand anders
was geschrieben hat, das auf
Twisted, ganz viele Leute haben Twisted halt als Basisbibliothek
für ihren Netzwerkrahmen benutzt,
aber man kann das dann halt nicht einfach so verwenden,
weil wenn man jetzt selber
auf was anderem aufsetzt, dann geht
das halt alles nicht und das war kein so
wirklich schöner Zustand.
Es war auch nicht total furchtbar,
das ging alles und man konnte irgendwie mit
Threads konnte man auch eigentlich quasi das schon
immer machen, irgendwie so IO-Multiplexen,
das ist halt das, was man vor allen Dingen macht, wenn man
jetzt irgendwie quasi
so asynchron
Dinge tun will.
Aber so wirklich schön war das alles nie und
jetzt inzwischen ist es aber,
gibt es da halt eine nette Syntax
für und das ist eigentlich ganz toll und das machen
ganz viele und genau,
das war damals alles noch
ganz weit entfernt.
Ja, dann, ach so, auch damals, was dazugekommen ist, Newstyle-Classes, das...
Was?
Newstyle-Classes.
Genau, die Klassen waren etwas anders davor und ja, genau, jetzt müsste ich noch nachlesen, was da genau die Unterschiede waren.
Ich glaube, also eigentlich weiß ich nur, dass man halt quasi dann immer nicht Doppelpunkt,
also Leerzeichen, Class, Name, Doppelpunkt geschrieben hat,
sondern irgendwie die ganze Zeit lang hat man immer auf Object geschrieben,
damit es halt von Object erbt und man New Style Classes automatisch verwendet,
was man jetzt halt auch schon eine ganze Zeit lang nicht mehr tun muss.
Also jede Klasse automatisch von Object dann, oder?
Ja, genau.
Und dann gibt es natürlich noch diverse
Meta...
Programmierungsgeschichten, Meta-Classes
und so. Ich weiß gar nicht, wann die dazugekommen sind.
Das gab es, glaube ich, am Anfang auch nicht.
Okay.
Ja, dann... Ach so.
Auch eine neue Syntax, die
sehr praktisch ist.
Das ist halt so...
Also es gibt List Comprehensions,
glaube ich. Die gab es auch nicht, aber dann?
Die gab es bei 1.5 noch nicht.
Es gab es bei 2.1, sind die, glaube ich, dazugekommen.
Also jedenfalls, als ich angefangen habe,
war das so, das war so eine neue
Geschichte, die dazugekommen ist. Dann kam, glaube ich,
dann weiß ich ja nicht, wann
die Generator-Expressions dazukamen, wo man
halt nicht eine List-Comprehension hat,
sondern dann quasi runde Klammern schreibt und dann
das Ganze ein Generator ist. Das könnte sein,
dass das erstmal zwei, vier war oder so.
Und jetzt gibt's
auch irgendwie so
Syntax für Dict-mäßige
Objekte. Also man kann halt auch geschweifte Klammer auf
und dann
V-Doppelpunkt
K-Komma
v in irgendein Addict.items
sagen und dann würde sich
Also kann man sich sein Addiction erst generieren.
Ja, genau. Und muss dafür
nicht extra irgendwie
nochmal Addict aufrufen oder so.
Ja, das ist jetzt, das ist aber dann
relativ spät dazu gekommen. Ich glaube, das ist erst
mit Python 2.3 oder Python 3
dazu
gekommen jetzt. Wofür
nutzt man denn jetzt eigentlich Python heute?
Ja. Insgesamt, vielleicht machen wir das
nochmal als Frage für unsere Hörer,
die das so genau wissen wollen. Genau,
Also am Anfang war es vor allen Dingen eine Skriptsprache zum Verbinden von irgendwelchen Systemen.
Man nannte die Dinge auch Glue Languages und so, weil es schön einfach ist, diverse andere in anderen Sprachen programmierte Libraries anzubinden und die dann halt irgendwie miteinander zu verbinden.
Hast du verschiedene Server-Module mit Python-Kleister dazu geklebt?
Ja, irgendwie sowas wie man hat Image Magic oder so eine Bibliothek, die jetzt auf Bildern irgendwas macht und hat dann halt irgendwelche Bindings, die das in Python verfügbar machen.
Und dann hat man irgendwie eine Bibliothek, die irgendwie Mails macht oder dann kann man irgendwie E-Mails mit Bildern oder so dann irgendwie verknusteln und dann E-Mails mit Bildern drin verschicken oder sowas.
Solche Sachen hat man halt in Python vor allen Dingen gemacht.
Weil man hat einmal das Bild in der Hand
und man hat einmal eine E-Mail in der Hand
und Python gibt dann den Kleber, dass man eine E-Mail mitbildet.
Genau, ansonsten, wenn man jetzt, keine Ahnung,
irgendeine Bibliothek hat, die in Zyklospos geschrieben ist oder so,
wenn man da jetzt irgendwie E-Mail-Support einbauen will
oder irgendwie eine andere Bibliothek,
die mal was anderes geschrieben ist, die einbinden will,
das ist halt sehr schwierig.
Und mit Python kann man das alles sehr schön integrieren.
Also für sowas hat man es vor allen Dingen verwendet,
aber auch für Web-Entwicklung von Anfang an
eigentlich schon, soweit ich weiß.
Welche Frameworks haben wir da groß?
Also ich kenne zum Beispiel Flask, habe ich in einem Tutorial
gelernt, und natürlich Django.
Ja, die kamen allerdings alle
sehr viel später.
Also, sagen wir mal so, es wurde
halt auch als CGI verwendet.
Als was?
Es gab es ganz früher.
Das ist schon fast ein bisschen
Opa als Held vom Krieg
Sektion. Ja, bitte, deswegen sind wir hier.
Es gab das
Common Gateway Interface. Das war halt eine
Methode, wie Web-Server
sozusagen Skripte aufrufen konnten,
die dann irgendwie, also
am Anfang gab es nur, am Anfang waren statische
Seiten, wo halt ein Webserver irgendwie eine Datei ausgeliefert hat.
HTML pur. Ja.
Und
das ist aber ein bisschen wenig,
wenn man jetzt also sowas hat wie eine Webseite mit
einem Gästebuch, sowas gibt es heute auch alles nicht mehr,
aber damals war das halt so, da musste man das haben.
Da musste man irgendwie einen Encounter haben.
Da hat er sein Gästebuch rum und rein. Ich war bei dir
im Internet. Genau. Ich habe da was
reingeschrieben, ich habe es benutzt.
Ja, und das geht natürlich mit statischen
Seiten irgendwie nicht. Also wenn
ich jetzt so ein Gästebuch habe und ich habe da ein
Feld, wo ich irgendwas eingeben kann und dann soll das
halt irgendwo gespeichert werden, dann muss
sozusagen der Text, der
in dieses Feld geschrieben wurde, irgendwie
durch ein Skript durch und das muss das irgendwo
hinschreiben. Und
damit solche dynamischen Sachen gehen,
gibt es halt dieses, damit
quasi irgendwie der Webserver mit
einem
Skript kommunizieren kann,
dass man halt irgendwie diesen Kram
liest und wegschreibt, gibt es
das Common-Gateway-Interface und das hat das
dann so gemacht, es hat dann halt das Skript gestartet,
also weggeforkt und dann irgendwie da
per Umgebungsvariablen irgendwie die Daten
übertragen. Das geht, aber
es ist halt furchtbar langsam und
alles nicht so richtig schön.
Aber so war das damals und da
ich erinnere mich auch, dass man
da durchaus Python-Skripte, also meistens hat man
Perl verwendet, aber das
ging auch mit Python schon.
Hatte halt so ein bisschen das Problem,
dass die meisten Hoster irgendwie kein Python installiert
hatten und deswegen man keine Python-Skripte
als CGI-Skripte irgendwie da
angeben konnte, aber
Musste man selber
hosten, wenn man Python-Skripte hatte. Ja, genau. Insofern war das
halt nicht so populär.
Ja, die ganzen
anderen Geschichten, das kam alles viel,
viel, viel später. Was war denn so das erste
Framework, was so mit hochkam, wo man die ersten
Seiten vernünftig mit... Das gab es für Python
gab es da eigentlich fast nix.
Also es gab
also das ist halt auch, da gab es
eigentlich nur PHP. Also da gab es Mod-PHP
für den Apache.
Es gab auch einen Mod-Python, aber das war ziemlich
furchtbar. Das habe ich mal versucht zu verwenden.
Ich habe es sogar eine ganze Zeit lang verwendet, aber das war alles
ziemlich scheußlich.
Hatte Memory Leaks, war alles irgendwie
ätzend, dauernd so komische Sachen passiert.
Also Memory Leak heißt
dann, der Server stellt ab, wenn den Leute benutzen.
Ja, man braucht immer mehr Speicher, man weiß
nicht genau warum und dann irgendwann ist er halt weg
und dann muss man halt nachgucken, was da schiefgelaufen ist.
Das ist nicht so schön. Das Mod-PHP war auch
nicht so toll, aber das hat halt so schon irgendwie ganz gut
funktioniert und
das war so die, auch die Anfang der Nullerjahre war so die
große Zeit des sogenannten
LAMP-Stacks, so Linux,
Apache, MySQL.
PHP?
PHP, genau.
Und
das hat so halbwegs funktioniert
und ja, Python
haben zwar Leute auch
quasi als Web-Anwendung verwendet, aber dann immer
ach doch, jetzt war es das erste,
was Leute tatsächlich da
in Python gebaut haben, war
Soap.
Ja, oder Soapy, ich weiß gar nicht genau, wie man das ausspricht.
Das gibt es bis heute
und das ist bis heute
irgendwie eine ganz tolle Community
irgendwie.
Und da gab es dann auch
so ein Content-Management-System oder irgendwie so ein Ding, was drauf
aufgesetzt hat, das nannte sich Plone. Also daran erinnere ich mich auch.
Und das muss irgendwie 2004 gewesen sein, als ich es zum ersten Mal
ausprobiert habe. Das war alles sehr nett.
Es war nur furchtbar langsam,
Aber ansonsten war es alles sehr schick.
Und ich glaube, das waren so die ersten,
die so irgendwie komplexere Web-Anwendungen
in Python möglich gemacht haben.
Wie gesagt, manche Leute benutzen das bis heute.
Dieses Projekt hat ein großes Problem
mit dem Umstieg von Python 2 auf Python 3.
Ich glaube, da ist noch eine ganze Menge Code nicht umgestellt.
Und ja, jetzt am 1. Januar 2020 läuft ja irgendwie
der Support
für Python 2.0.
Das ist nicht mehr so wirklich viel Zeit.
Und keine Ahnung, also vielleicht
haben sie das auch mittlerweile geschafft, dass sie da umgestiegen
sind, aber
das ist ein bisschen blöd für dieses Projekt.
Ja, aber das waren so die ersten, genau.
Und dann kam halt
mehr dazu,
als es eine standardisierte,
schöne Schnittstelle gab. Also es gab dann diverse Schnittstellen,
die auch besser funktioniert haben als CGI.
Es gab fast CGI.
fast CGI? Ja, genau.
Das war schneller. Das war schneller, da
musste der Server das Skript nicht forken, sondern
da waren da schon so ein paar Skripte
gepreforkt und dann konnte man das irgendwie, dann wurde
und die Daten da halt irgendwie
in der Prozesskommunikation irgendwie hingeschoben
und das war alles deutlich besser, das ging halt dann
relativ schnell. Aber es war
auch alles noch ziemlich hässlich und
es gibt dann, ich weiß nicht, wann das passiert ist,
müsste dann so Mitte der Jahre gewesen sein,
da gibt es dann halt, seitdem gibt es irgendwie
Mod, gibt es halt Whiskey
sozusagen als Schnittstelle zwischen Web-Server und
Applikation. Also
sich das so halbwegs standardisiert hat.
Hört sich nach etwas ziemlich Holzigen zu trinken
an.
Ja, also wird aber
WSGI geschrieben.
Es wird nur lecker ausgesprochen.
Es ist
nicht so lecker, wenn man es
sich dann tatsächlich anguckt, aber
genau. Und damit ist dann eigentlich auch schon
die große Zeit von Apache als
Web-Server irgendwie so ein bisschen vorbei.
Da tauchen dann plötzlich so andere Server auf,
die man halt als Applikationsserver häufig verwendet.
Beziehungsweise man trennt dann eigentlich zwischen Applikationsservern
und irgendwie den Servern, die halt statische Verhalte nach außen ausliefern
oder die so ein bisschen Reverse-Proxy halt vor den Applikationsservern sind.
Da nimmt man meistens auch nicht Apache, sondern dann sowas wie Nginx
oder am Anfang gab es dann Lite, HTTPD und so.
Und heute vielleicht, heute nimmt man dann irgendwie sowas wie,
na, wie heißt der noch?
Caddy. Ein Google-geschriebener
Webserver, der sich schön
auch mit Let's Encrypt irgendwie
verbindet und dann hat man halt irgendwie
ordentliches SSL nach draußen,
irgendwie automatisch, muss da nicht irgendwie...
Also bei Nginx, also ich habe mich
beschäftigt, Nginx so weit zu kriegen,
dass es halt irgendwie beim Test von
SSL-Labs irgendwie überall grün und okay ist.
Das hat mich irgendwie so zwei Tage gekostet
und war irgendwie echt aufwendig.
Und bei Caddy
geht das einfach so, muss man
Das ist schon super. Also den verwende ich jetzt mittlerweile auch meistens vor den Applikationsservern. Applikationsserver sind sowas wie Junicorn, den verwende ich meistens, oder Mew, wie ist GI, oder U, wie ist GI, heißt ein anderer, oder Werkzeug, oder da gibt es einige, die man halt verwenden kann.
Und die sind sozusagen dafür zuständig quasi, dass da drin die Applikation läuft und die Requests, die halt sozusagen nur von der Applikation beantwortet werden können, die gehen halt dann an diese Server und die rufen dann halt eben quasi die Applikation mit der entsprechenden API auf.
Also ich wollte jetzt gar nicht unterbrechen,
ich fand es nämlich auch super interessant.
Ich glaube, wir machen vielleicht sogar noch eine eigene Web-Folge.
Wir sind ja heute, das wollte ich nicht vergessen,
ich hoffe, die Anfänger sind jetzt nicht alle schon ausgestiegen,
in der Anfänger-Folge.
Deswegen müssen wir noch ein bisschen mehr eingehen darauf,
welche Funktionen man mit Python vielleicht noch machen kann.
Also wir haben jetzt vielleicht einen kleinen Einstieg
schon mal euch gegeben, was es so an coolen Möglichkeiten
heute so gibt mit Python und Web-Frameworks.
Was machen wir noch?
Genau, das ist heute auch ein wichtiger Teil,
Glue ist auch noch immer ein wichtiger Teil.
Ich habe jetzt letztens, also um vielleicht kurz Werbung zu machen
für einen englischsprachigen Python-Podcast,
das war Talk Python to Me, glaube ich.
Doch, ja, Talk Python to Me.
In der letzten Folge, da ging es um Python 3 bei Facebook.
Und da erzählte jemand, der halt Python bei Facebook irgendwie macht,
dass die ganzen Backend-Systeme, die halt irgendwelche Services machen
oder irgendwie Sachen hoch runterfahren,
Sachen deployen, das
ganze quasi Facebook-Management
Zeugs, das ist halt alles
Python. Also Frontend ist
zwar PHP, aber alles, was sozusagen
Services
miteinander verbindet oder halt
irgendwie interne Geschichten macht, das ist halt bei
Facebook alles in Python.
Also auch YouTube ist in Python.
Ja, genau, YouTube ist so ein bekannter
NASA, macht viele Sachen mit Python.
Ja, bei Disney zum Filme
produzieren und
Ja, Pinterest auch. Ich weiß nicht genau, die waren sogar Django irgendwie. Aber auch Python hauptsächlich. Instagram ist komplett Python eigentlich von der Web-Applikation her. Also ja, es gibt auch durchaus im Frontend einige, die da Python verwenden. Aber es ist halt im Grunde überall.
Ja, also dieses Glue-Ding ist auch immer noch eine sehr, sehr wichtige Geschichte. Aber dann gibt es halt einen neuen Bereich seit einigen Jahren, der halt auch sehr, sehr populär geworden ist. Das ist halt so ganze Data Science, Machine Learning-Gebiet.
Diese Sensor-Daten-Erfassung.
Ja, Scientific Computing, dieser ganze Bereich.
Also das, was man früher in so einem Matlab gemacht hat, würde ich sagen.
Ja, oder Mathematiker auch.
Mathematiker hat ja dieses schöne Konzept entwickelt von diesen Notebooks.
Also das kennt man vielleicht, wenn man jetzt im wissenschaftlichen Bereich ein bisschen unterwegs war.
Es gibt so Labortagebücher oder so, wo man aufschreibt, was man irgendwie tut und so.
Python, die Jupyter-Notebooks, die es jetzt gibt.
Genau, die gibt es in Python und
bei
Mathematik hatte das tatsächlich zuerst
sozusagen dieses Feature, dass man halt
solche Notebooks halt dann
ausführen kann und dann halt nachvollziehen kann, was da
passiert ist oder wie man zu einem bestimmten Ergebnis gekommen ist.
Sehr, sehr gute Idee halt.
Hat sich nie so richtig
durchgesetzt, weil Mathematik ist halt proprietär
und teuer und
ist auch eine sehr exklusive
Community irgendwie und
hat irgendwie nie so richtig abgehoben, obwohl es
eigentlich schon eine sehr schicke Idee war. Und dann wurde
die halt aufgegriffen von
den Leuten, die irgendwie so einen
Interpreter oder man nennt das
irgendwie so Ripple, weiß gar nicht
wofür diese Abkürzung, also diese
Shell, die man bekommt,
wenn man jetzt Python eingibt.
Was sie IPython jetzt in dem
Falle tatsächlich. Ja, die haben
die haben halt sozusagen das damit
reingebaut und das nannte sich dann IPython Notebook.
Also IPython hatte schon den ganzen Teil der Funktion, die man dafür braucht, wenn man sowas implementieren will.
Und IPython-Notebook hat dann halt quasi sozusagen die Ideen von diesen Mathematica-Notebooks irgendwie aufgegriffen.
Und ja, das war ein toller Erfolg.
Man hat das dann auch für andere Sprachen gemacht, für R und für Julia.
Und dann war irgendwie klar, dass IPython-Notebook ein blöder Name dafür ist,
weil wenn es halt nicht mehr Python ist, sondern auch andere sehen,
Dann wurde das halt umbenannt in Jupiter, wobei das halt nicht
Jupiter wie der Planet geschrieben wird, sondern mit
P-Y, halt wie für Python, weil
es dann Julia, Python, R
quasi, also die
drei Sprachen, die da halt hauptsächlich irgendwie
verwendet werden. Das sieht ja ganz schick aus,
habe ich tatsächlich auch schon ein paar Mal gesehen, das kann man
tolle Sachen mitmachen und auch live den Code direkt testen,
ausführen, was man damit macht. Genau, genau, das ist
halt super praktisch, das ist natürlich jetzt schwer, so
das zu umschreiben, jemanden,
der das nicht kennt, quasi
warum das toll ist,
ist es halt nur so,
gerade bei so... Naja, stellt euch vor, ihr könnt
ein Buch lesen und habt ja irgendeine statistische
Tabelle, die ihr anguckt und ihr könnt
live da die Daten eintragen, ändern und auch
im Schaubild verändert sich direkt mit
den neuen Datensätzen das, was ihr da
braucht, was ihr programmiert habt, der Algorithmus,
um das darzustellen, könnt ihr direkt live sehen,
was da passiert. Ja, das ist
eine der schönen Geschichten, aber was für mich vor allen Dingen,
also ich mache auch viel
Data Science-Geschichten,
dass das für mich sozusagen das
Top
Feature ist, ist halt
Und viele der Schritte brauchen eine Menge Zeit.
Also wenn man große Datenmengen hat oder so,
kann es sein, dass manchmal, wenn man irgendwas macht,
dauert das halt eine Stunde.
Und dann hat man das Ergebnis.
Irgendeine Berechnung, genau, die man macht.
Irgendwann trainiert man irgendein Modell oder so.
Und das rechnet dann halt irgendwie so eine Stunde vor sich hin.
Und wenn man das jetzt alles in einem Skript hat,
so wie man das normalerweise hat,
dann erzeugt man dieses Modell,
dann macht man da irgendwelche Evaluationen drauf,
dann visualisiert man das Ganze,
dann macht man da irgendwelche Tests.
Da muss man erstmal die ganze Arbeitsschrittkette durchgehen,
bis man wieder an dem Punkt ist, den man gerade geändert hat.
Genau. Man kann das natürlich dann irgendwie schlau cachen.
Das habe ich früher dann so gemacht.
Da habe ich dann irgendwie Dekoratoren benutzt,
die dann halt den Kram immer irgendwo hingeschrieben haben
in ein Verzeichnis.
Und dann sozusagen immer wieder nur
die Arrays, die dabei entstehen,
halt wieder zurück.
Aber das ist halt alles nicht so...
Also das kann man machen, aber diesen Aufwand treibt man auch nur dann,
wenn man sich sicher ist, dass man das wirklich braucht
und dann verändern will.
Und jetzt möchte man halt am Schluss dieser Kette,
die halt irgendwas erzeugt, irgendwie eine Funktion schreiben,
die irgendwas mit den Daten macht.
Und jetzt baut man da einen blöden Fehler rein oder so.
Und das passiert einem tatsächlich,
wenn man das jetzt so, wie ich das auch früher gemacht habe,
passiert einem das relativ häufig,
dass man dann halt den Fall hat, dass irgendwie es geht irgendwas schief.
Man sieht einen Trace weg und denkt sich schon so,
oh nein, was für ein blöder Fehler.
Und das Ergebnis von irgendwie einer Stunde Berechnung oder so ist weg
und man muss halt im Grunde nochmal eine Stunde warten.
Aber selbst wenn man nur ein paar Minuten warten muss,
ist es halt voll blöd, weil man ändert irgendwas,
probiert es aus, Zyklus halt,
wenn da viel Latenz
drin ist, dann wird man sehr langsam
und dieses Problem
löst Jupyter eigentlich, lösen die Jupyter
Notebooks komplett, weil da ist es halt
so, dass man jede Zelle getrennt
ausführen kann und wenn man jetzt eine Funktion geschrieben hat, die
einen Fehler enthält und führt die halt aus
auf den Daten, die man jetzt da
irgendwie eine Stunde lang berechnet hat und es geht schief,
dann ändert man die Funktion, führt sie nochmal
aus und alles ist gut und das Ergebnis
ist halt nicht weg und das ist halt super.
Wenn man sowas arbeiten möchte, ist das glaube ich...
Genau, und das macht einen halt viel, viel schneller.
Und das ist halt total toll.
Ist das auch für Anfänger sehr gut geeignet, würdest du sagen?
Auch zum Lernen der Sprache?
Ja, weil es halt so schön interaktiv ist.
Man kann einfach eine ganze Menge ausprobieren,
ohne dass man jetzt irgendwie
Editor lernen muss und ohne dass man
irgendwie quasi wissen muss.
Also das, ja,
man kann halt einfach direkt was ausprobieren. Wenn es halt schief geht,
dann ändert man die Zelle und führt sie nochmal aus und dann ist es okay.
Ja, das bringt uns, glaube ich, direkt zu unseren Anfängertipps.
Ich glaube, das wäre gar nicht so schlecht.
Also wenn ihr Fragen habt, natürlich direkt irgendwie
an hallo.pythonpodcast.de
einfach stellen. Dann erklären wir euch
auch alles, was ihr gerade vielleicht noch nicht verstanden habt oder was
euch ein bisschen zu schnell ging.
Gleich mit ein paar Tipps anfangen.
Ich glaube, ganz wichtig ist natürlich die offizielle
Dokumentation. Aussage des Tools zum
Lesen. Ich glaube, da findet man so die meisten
Erklärungen für die Standardbibliothek, wie das alles
so funktioniert. Außerhalb von den
Tutorials, die es jetzt gibt. Ich habe zum Beispiel
mit Python the Hard Way angefangen und das
Buch von Seth Torr gelesen. War ein ganz guter
Einstieg.
wenn man sich da so durcharbeitet, kommt man relativ tief
in die Materie rein. Es gibt noch
Automated Boarding Stuff mit Python.
Geht auch auf deutschem Buch zu. Das kostet
leider Geld, ansonsten ist das ein kostenloses Tutorial.
Ja, die ganzen Tutorials gibt es sonst
nicht auf Datacamp, Udemy, Udacity,
unzählige kostenlose.
Ja, du hast ja gerade gesagt,
anfangen vielleicht mit Jupyter Notebook oder
einem einfachen Text-Titel. Also ich kann jetzt
nicht empfehlen, direkt mit einer großen Entwicklungsumgebung
zu starten. Das hält dann erst mal
so ein bisschen auf. Gibt ja dann
irgendwann später ganz viele tolle Editoren,
PyCharm, Idle, VS Code,
VEye, Atom, MX.
Was benutzt du?
VEye.
Ich benutze aber auch PyCharm
zum Beispiel mittlerweile, weil mich nervt, dass es halt
doch relativ langsam ist.
Eigentlich ist das schön, also diese ganzen
IntelliJ-EDEs,
das ist alles schon sehr nett gemacht,
die können auch sehr viel, aber
die reagieren nicht so instantan.
Also es ist immer, wenn man irgendwo drauf drückt oder so, dann
muss man erst mal, es ist so...
Zu langsam. Es ist einfach zu langsam.
Es ist nicht so,
es fühlt sich halt nicht so
snappy irgendwie ordentlich
an, wie sich halt so ein Profi-Werkzeug anfühlen
sollte, sondern es fühlt sich halt immer so an
wie, keine Ahnung,
wie diese, weiß ich nicht,
also ich meine, gut, das ist ein böser Vergleich, aber wenn man
so einen Fahrkartenautomat bei der Bahn steht und
drückt er drauf, und dann
passiert einfach nichts und dann drückt man nochmal
drauf und dann macht es irgendwie so
Kennt ihr das, wenn ihr euch gerade so einen Schokoriegel
aus dem Automaten ziehen wollt und dann bleibt der irgendwo da oben
hängen? Ja, und das ist halt
schon sehr
so ein bisschen nervtötend und deswegen benutze ich das
eigentlich nicht so gern, obwohl manche Features halt
durchaus so nett sind, dass ich es halt auch
immer wieder verwende, aber
wenn ich BI verwenden
kann, dann verwende ich eigentlich, also
WIM, da hat sich auch einiges getan.
Wie hast du denn Python gelernt?
hast du da irgendwie Tutorials
gemacht oder warst da direkt drin? War das so
Basics, dass man alles selber beibringen musste?
Ja, aber es gab nicht so viele
Bücher damals.
Es gab ein paar, die waren
aber auch alle nicht so wirklich hilfreich. Also doch, es gab
ein Buch, das war hilfreich. Ich weiß aber nicht, ob
das immer noch eine gute Empfehlung
ist. Es war das Python Cookbook.
Das war ganz gut.
Ansonsten waren die meisten
Bücher nicht so toll.
Und ja,
wie habe ich es gelernt?
Ich hatte das Glück, dass ich da neben jemandem gesessen hatte,
der das schon konnte.
Und wenn er mir das dann gesagt hat,
das war etwas lukriöse.
Das war relativ praktisch.
Das kann ich auch tatsächlich empfehlen.
Versucht nicht nur im stillen Kämmerlein zu sitzen
und euch selber durch den Kram zu quälen.
Es geht bedeutend schneller und ihr kommt auch bedeutend schneller weiter,
wenn ihr tatsächlich jemanden habt,
der euch so ein bisschen zeigt, wie das Ganze geht.
Danke, Jochen.
Deswegen sitze ich ja hier und stelle dir die ganzen doofen Fragen.
Man könnte auch zu Meetups
durchaus gehen, sich da mit Leuten
austauschen hilft.
Die tägliche Arbeit muss man
natürlich dann trotzdem machen, aber ich glaube, mittlerweile
kommt man da ganz gut angeleitet auch
in die ersten eigenen Projekte so rein.
Ja, wie funktioniert
Python eigentlich?
Was ist das Ding? Wo kann man
das machen? Also ich habe jetzt hier zum Beispiel auf meinem
großen Zettel stehen, simple Prototyping
kann man machen und recht umfangreiche
Bibliotheken.
Ja, also Python selbst ist halt eine...
Einfach.
Ja, es verbindet halt zwei Dinge,
die eigentlich sich ein bisschen widersprechen.
Es ist halt sehr einfach
und es ist halt trotzdem sehr mächtig.
Das macht es halt sehr schön.
Auf der anderen Seite bedeutet das halt,
dass es nicht so einfach ist,
das irgendwie in Binärcode zu kompilieren oder so.
Das ist halt mit einer Sprache,
die halt wesentlich einfacher sozusagen ist,
ist das halt simpler.
Also wenn man C nimmt,
so ein mehr oder weniger Makro-Assembler,
da kann man dafür einen Compiler zuschreiben.
Warum muss man denn überhaupt etwas in Binärcode
kompilieren?
Wenn es ein Computer direkt ausführen
können soll, dann muss das irgendwie
Maschinencode sein.
Binärcode, Nullen und Einsen.
Genau.
Wenn das so etwas ist, dann kann es
halt direkt ausgeführt werden. Also die
meisten Programme, die man so kennt, sind das halt auch.
So wie früher, wenn ich mir das so vorstelle,
da hat man ja die ganzen großen Rechner gehabt,
die Lochkarten gelesen haben für Nullen und Einsen.
Das braucht der Computer auch heute noch, damit er versteht,
was er da überhaupt machen muss.
Ja, genau. Und dann läuft halt dieses Programm
direkt irgendwie auf dem Prozessor
und
ja, aber das geht halt, das ist halt
etwas, was dann nicht mehr geht mit Python, weil
für Python Compiler zu schreiben ist halt dann
nicht mehr so einfach.
Oder eigentlich mal so ziemlich unmöglich, weil das ist halt alles
dynamisch und zur Laufzeit kann sich eine Menge ändern.
Das geht halt nicht so richtig.
Das ist halt dann der Preis, den man zahlt,
dass man es nicht mehr kompilieren kann.
Es wird dann halt interpretiert, also es wird schon so ein bisschen
verändert. Es wird
in Bytecode verwandelt
und der Whitecode wird dann interpretiert von einer virtuellen Maschine.
Das sind dann die PyC-Dateien, die man findet, nachdem man irgendwas gelaufen hat.
Genau, genau.
Also C ist das, was dann das Ganze benutzt, um das dann für die Maschine schreiblesbar zu machen?
Ja, aber für die Maschine ist das nicht lesbar.
Man braucht immer noch den Python-Interpreter, der das dann ausführen kann.
Also der Python-Interpreter ist halt genau diese virtuelle Maschine
und der kann das dann halt ausführen.
Und das hat dann auch so einige andere Nachteile.
das macht es halt auch schwer, Sachen zu installieren
oder so, weil man
kann jetzt nicht einfach irgendwo
ein Binary runterladen
oder verschicken. Wieso, es gibt doch PIP.
Ja, genau, dann muss man dann eben zu
so Paketmanagern greifen,
mit denen man irgendwelche Dinge installieren kann,
aber man kann halt jetzt nicht irgendwie auf dem USB-Stick
jemandem irgendwie
Python-Programm geben
und der startet das dann halt.
Also, wenn ich das richtig verstanden habe, PIP ist dann
dieser Paketmanager, der über die Seite
PyPy oder wie es ist, über den Server von dir
läuft und dann da Pakete
installiert, die andere dort bereitgestellt haben,
die schon so mit veröffentlicht sind.
Das heißt, wenn ihr eure eigenen Pakete baut,
müsst ihr die entweder so veröffentlichen oder
tatsächlich externe Bibliotheken
nehmen, um Installer zu bauen oder sowas.
Genau, das gibt es auch. Es gibt High-Installer,
es gibt diverse Geschichten, die das dann halt versuchen
irgendwie in Binary zu packen. Und das
funktioniert auch manchmal.
Kannst du kurz zwei, drei Installer nennen, die man
versucht für verschiedene Systeme? Einmal vielleicht für Linux,
für OS oder für Windows oder so?
Ich benutze das selber nie.
Bei Linux braucht man es, glaube ich, nicht groß.
Nee, da gibt es, glaube ich...
Baust du ein Paket, machst du ein Shell-Install-Setup-Py, was?
Nee, aber da gibt es auch, also unter Linux gibt es auch so ein Ding,
was halt quasi den Interpreter mit reinpackt in Binary.
Pye-Installer?
Kann sein, dass es Pye-Installer ist.
Und wenn man da so ein bisschen aufpasst,
dann kriegt man den Interpreter relativ klein.
Also wenn man es einfach naiv macht, dann
kann es sein, dass es irgendwie so 15 MB
sind oder 10, ich weiß nicht genau.
Aber man kriegt es auf irgendwie 2, 3 runter,
wenn man sich da ein bisschen Mühe gibt.
Und dann ist es eigentlich, ich meine, heutzutage ist das eigentlich
sowieso alles nicht mehr so wild.
Dann ist es halt so, es gibt natürlich Leute,
die sagen würden, wenn ich
das mit C mache und dann gut
und nicht gegen die Lip C linke
oder gegen die G-Lip C, sondern halt irgendwie
so eine Diät-Lip C
oder irgendwas anderes, keines.
Jetzt hören wir gerade kurz wieder. Lip C, G-Lip C,
das sind die Standardbibliotheken, die CISO bereitstellt
für die Befehle, die dann das Ganze größer machen,
wenn man das kompiliert, oder? Genau, da ist ein bisschen
Standardbibliothek dabei, aber eigentlich, wofür die da sind,
ist die Kommunikation mit dem Kernel,
mit dem Betriebssystem, sozusagen.
Und das kann man natürlich auch beliebig komplex
gestalten, aber wenn man halt nur die ganz
simpelsten Dinge haben will,
dann muss das nicht so groß sein,
weil das Problem ist, es muss halt irgendwie dagegen gelinkt sein,
damit
irgendwie der Prozess überhaupt irgendwas machen kann, wie
Eingabe, Ausgabe und so.
Aber wenn man das schlau macht, dann kriegt man das halt
auf, weiß ich nicht, ein paar hundert Byte oder so runter.
Und das ist natürlich was ganz anderes, als wenn ich
jetzt irgendwie megabyteweise Zeugs...
Das könnte auch ein Mikrocontroller packen. Ich glaube, man kriegt das
sogar in so einen Bootsektor rein. Wie hat so ein Bootsektor
512 Bytes oder sowas?
Keine Ahnung, ja.
Also natürlich ist es nicht so
klein, wie es gehen könnte, wenn man das wirklich
drauf anlegt.
Und das wird auch nie gehen mit Python so richtig.
Aber also
heutzutage sind ja auch ein paar Megabyte eigentlich
ja, nicht mehr wirklich viel.
Luxus.
Früher war das doch sehr schlimm, heute...
Band zurückspulen oder sowas, ja.
Genau, und daher ist das
eigentlich auch alles nicht mehr so wild. Aber man muss auch sagen, dass
dieses Thema so ein bisschen vernachlässigt wurde,
gerade auf Windows und so,
kann man ja auch nicht davon ausgehen, also bei den meisten
Linux-Systemen wird halt einfach ein Python-Interpreter
vorinstalliert sein, vielleicht ein uralter, aber immerhin.
Aber bei Windows ist halt Python
nicht vorinstalliert und wenn man
irgendjemandem ein Python-Script schickt oder so, kann der halt
nichts damit anfangen. Das ist ein bisschen
ein Problem. Das ist halt auch ein bisschen
Preis, den man dann halt zahlt, dafür,
dass es halt einfach ist,
aber trotzdem sehr mächtig.
Und ja, also
Die Beine ruhig, das kriegt ihr natürlich
trotzdem auf der Python-Room-Stage direkt
für die jeweiligen Systeme und wenn das
Der Python-Interpreter selber ist natürlich
wieder quasi so ein Bein.
Einige Leute empfehlen auch Anaconda, das ist irgendwie so ein Paket,
womit man ganz viele tolle Datensachen machen kann,
wo es vorinstalliert ist. Also ich persönlich
hatte da nicht so die besten Erfahrungen mit, das war immer
sehr verwurschtelt mit den Paketen
und dann lief immer was nicht, wenn es irgendwie ein Update gab
von den neuesten Python-Versionen, die haben auch einen eigenen
Paketmanager, einen Conda irgendwie
und deswegen würde ich das für Anfänger jetzt nicht unbedingt
sofort empfehlen, obwohl viele das machen,
aber das könnt ihr ja selber schauen.
Ja, ja, Anaconda ist ein bisschen verwirrend, weil
also eben, es ist eben kein Paketmanager
und auch nicht, also Anaconda
ist eine Distribution sozusagen von
Paketen, aber
Conda ist der Paketmanager
und es gibt auch noch ganz viele andere
Pakete, die jetzt nicht in der Anaconda
Distribution drin sind und
das ist so ein bisschen alles
Eigentlich ist das alles ein bisschen furchtbar.
Man muss sagen, dass es schön wäre,
in einer idealen Welt hätte man das ja gerne,
dass man einen Paketmanager für alles verwendet.
Es gibt auch so ein bisschen die Utopie,
wird so ein bisschen gelebt bei NixOS.
Da versuchen Leute, das tatsächlich noch umzusetzen.
Oder eigentlich waren auch die Linux-Distributionen
mal so quasi gedacht,
dass man halt einen Paketmanager hat,
mit dem installiert man halt irgendwie alles,
was man irgendwie haben möchte.
es geht ja auch jetzt noch, wenn man jetzt ein Debian hat
beispielsweise, dann kann man auch ein NumPy
oder so, was ja
quasi ein Modul ist für
Scientific Computing, ein Modul für Python,
kann man durchaus per Debian-Paket
installieren, also über die Distribution.
Es ist halt nur so, dass man das nicht tun sollte,
weil dann bekommt man eine Version, die nicht optimiert ist,
wo der Maintainer, also ich meine, vielleicht ist es auch gut,
ich weiß keine Ahnung, aber
die Wahrscheinlichkeit ist hoch, dass es eben
dann nicht schnell ist, weil
es ist halt nicht gegen MKL, diese
Mathe-Bibliothek von Intel gelingt
beim Kompilieren. Also man muss,
es ist halt tricky, das zu kompilieren, da ist viel
Core-Transworks dabei. Das ist alles nicht so
einfach und
ja, überfordert möglicherweise halt
ein Debian-Meter auch so ein bisschen.
Also du würdest auch immer alle Pakete
über PIP installieren, oder?
Naja, nee, ich würde sagen, es kommt drauf an. Also leider
haben wir nicht, also am schönsten wäre es,
wir hätten einen Paketmanager für alles.
Also zum Beispiel PIP oder deinen Distributionsmanager?
Nee, sowas wie ABT oder genau, oder
weiß nicht was dabei,
Yam für Red Hat gibt.
DNF ist mittlerweile, glaube ich,
auch bei Red Hat, zumindest bei Fedora.
Ja, ich bin
da auch gar nicht mehr so am Laufen, aber
genau. Wenn man einen
Paketmanager hätte, mit dem man alles installiert
und dann sich relativ sicher sein könnte,
dass das halt irgendwie funktioniert, das wäre schön.
Aber es hat sich
jetzt aber eher so entwickelt, dass
jede Programmiersprache so ein bisschen ihren
eigenen Paketmanager mitbringt.
Bei Python ist es halt
erst mal pip, so wie bei
Ruby sind das diese Ruby Games,
bei Perl ist es
Sepan, beziehungsweise, ich weiß gar nicht,
was jetzt das Ding ist, mit dem man die Dinger installiert.
Dann bei,
weiß ich nicht, JavaScript ist es halt
npm oder yarn oder was auch immer man da gerade
verwendet.
Und
das ist dann natürlich nicht mehr so toll,
weil das Problem ist, dass, wenn man
die jetzt benutzt, die Sachen,
wenn man die jetzt quasi einfach
so ins Routefile-System installiert,
dann überschreiben die natürlich Sachen, die die Disposition
da reingeschrieben hat.
Überschreiben sich gegenseitig.
Alles nicht so schön.
Niemand hat darauf aufgepasst, dass die Sachen auch alle miteinander
klarkommen.
Das heißt, es können die komischsten Dinge passieren.
Das ist halt nicht so toll.
Was macht man denn da?
Dafür versucht man das dann irgendwie
zu isolieren und installiert
Dinge nur in Environments.
Also in virtuellen Entwicklungen.
Virtuelle Umgebungen, genau.
Oder für seinen einen User. Also zum Beispiel pip install
Paketname minus minus User.
Wird halt das für den aktuellen Nutzer nur installieren?
Genau, das kann man auch machen.
Und das sind halt so ein bisschen krückige Lösungen für dieses Problem.
Aber leider ist es sogar noch schlimmer.
Es ist jetzt nicht nur so, dass jeder Programmiersprache einen eigenen Paketmanager hat,
sondern es sieht so ein bisschen, also jedenfalls bei Python ist es leider so,
dass auch jede Community ihren eigenen Paketmanager nochmal hat.
Also die ganze Web-Community verwendet eigentlich überwiegend PIP,
während die ganze Data-Science-Community überwiegend Conda verwendet.
Und man sagen muss, Conda ist ein bisschen mächtiger als PIP.
Man kann damit nicht nur Python-Pakete installieren,
sondern halt auch diverse andere Binär-Pakete.
Und manchmal muss man das halt dummerweise auch,
weil viele der Sachen, die man da verwendet,
sind halt Fortran-Bibliotheken oder irgendwelche C-Bibliotheken.
Warum verwendet man denn Fortran- oder C- oder C++-Bibliotheken in Python?
Ja, genau.
Das ist halt auch, weil, wenn man jetzt zum Beispiel Matrizen miteinander multiplizieren will oder so,
dann könnte man das natürlich auch in Python machen, indem man einfach For-Loops ineinander schachtelt.
Also man speichert die Dinger einfach quasi als zweiendimensionale Listen oder so.
Einfach eine Liste von Listen und dann quasi eine Liste von Spalten oder Zeilen.
Moment, NumPy, glaube ich.
Ja, ja, genau, aber man könnte es direkt in Python machen, dann macht man halt irgendwie so eine dreifach verschachtelte For-Loop und iteriert über die Dinger und rechnet das dann halt aus.
Das kann man machen, ist halt dann sehr, sehr langsam.
Wenn man jetzt so eine Bibliothek benutzt wie NumPy oder so, die haben dann halt einen speziellen Array-Type sozusagen.
Und wenn man da jetzt sagt, multiplizieren wir mal A und B,
dann nutzt NumPy unten drunter halt quasi,
weiß ich jetzt gar nicht, was man da mal spritzen möchte.
Ich muss mir jetzt gerade so auszumalen, wie das dann so aussieht in einem Schaubild,
um mir das irgendwie so ein bisschen vorzustellen, warum das jetzt schneller geht.
Also die benutzen drunter einen neuen Motor.
Benutzen drunter optimierte Fortran-Bibliotheken.
Oder ist es, ich weiß gar nicht mal, ob es Fortran ist unbedingt.
Also es ist halt irgendwie, die haben halt damals angefangen
mit Blas, Lapak, Atlas.
Das sind so die Dinger, die da unten drunter liegen.
Und es gibt, glaube ich, irgendwie so eine
definierte Schnittstelle für solche
für diese ganzen
Operationen. Und dann
sind das irgendwie Implementationen davon.
Und ja.
Nennen wir es Magic.
Genau, Magie.
Fortran ist halt irgendwie, als Sprache ist es immer noch
deswegen so wichtig, weil da Sachen sich quasi mehr oder weniger
automatisch vektorisieren lassen. Das bedeutet,
dass man nicht loopt über Sachen,
sondern dass
der Prozessor das
quasi übernimmt.
Also wenn man das einfach an C kommt,
kann man natürlich auch eine Loop hinschreiben. Wäre schon viel schneller als ein Python.
Wahrscheinlich so tausendmal schneller oder so.
Aber
selbst das wäre deutlich langsamer als das, was
quasi die Bibliotheken, die
unter dem Nampal liegen, halt machen.
Genau. Hat so ein bisschen
den Nachteil, dass man halt den Code anders
strukturieren muss. Man kann eben dann keine Vorschleife mehr
verwenden, sondern man macht eher solche Sachen
wie man
auf den Objekten, die man erzeugt hat, wie zum Beispiel
irgendwelche Arrays oder so, ruft man dann halt
irgendwie eine Funktion auf und übergibt dir einen Callback
oder so. Weil vor Schleifen gehen halt nicht mehr.
Das ist ein bisschen komisch,
aber ist halt dafür schnell.
Mir ist das so ein Trade-off.
Kann man sich überlegen, ob man sich das angewöhnt hat, dass man
das gerne macht oder ob man sagt, hey, wir nehmen jetzt das
ein bisschen kaufen. Python ist ja immer
als langsam verschrien, aber wenn wir den auch schnell bekommen,
ja okay, dann machen wir vielleicht mal einen kleinen Umweg.
Genau, genau. Ja, kommen wir vielleicht
gleich noch zu, wenn es um die Mythen geht.
also das ist, man kann damit
auch sehr schnell Dinge tun und
dafür muss es halt auf Bibliotheken
basieren, die das halt auch schnell machen können und
für Scientific Computing und Zeugs ist
es halt vortragend oft.
Ja, genau.
Ja, vielleicht nochmal genau zu diesen ganzen Bibliotheken,
die man machen kann. Du hast gesagt, glaube ich, Data Science
kann man ganz viel machen und Web kann man ganz viel machen
und für diesen Glue,
also den Klebstoff zwischen einzelnen Modulen, kann man
ganz viel machen und so zum Skripten.
Fällt dir noch irgendwas ein?
Ja, was ich ein bisschen vernachlässige,
Genau, auch ein Bereich, der momentan sehr interessant
wird, ist so
Home-Automation-Zeug,
Smart Home. Ich glaube, der Raspberry Pi, der macht
ja ganz, ganz viel. Ja, genau, Raspberry Pi wird da
oft verwendet und überhaupt Raspberry Pi
und Python haben viel,
viele schöne Anwendungen,
da kann man viel drauf machen.
Home-Automation, du hast ja, glaube ich, ganz viele
schöne Sachen mit. Ja, ich habe auch einen Raspberry Pi
irgendwo im Schrank stehen, der zum Beispiel
Temperaturen ausliest, indem man,
ich habe so ein DVB-T-Modul da
reingesteckt, die gibt es jetzt irgendwie günstig, weil es gibt kein
DVB-Thema. Ich wollte gerade sagen, also das ist doch gerade abgeschaltet worden.
Richtig, jetzt kann man die Dongle
kriegt man relativ willig
und da ist so eine Antenne dran und dann
habe ich hier irgendwie so Sensoren und die funken
halt auf den Frequenzen, ihre Werte
halt so alle paar Sekunden oder so
und dann muss man die eigentlich dann nur
einsammeln und dann an
es gibt ein Software, das nennt sich Home Assistant
schicken, also das ist ein bisschen komplizierter.
Ja, da machen wir auch noch eine eigene Folge. Genau.
Aber solche Sachen, also wenn man
zum Beispiel... Also ich sehe jetzt aber zum Beispiel keine
Schläuche in den Pflanzen, die du hier in deinem schönen
Wintergarten stehen hast. Das heißt, das musst du noch selber gießen.
Genau, ja, furchtbar.
Da musst du unbedingt automatisiert
werden. Ich weiß nur nicht, wie ich den Wassertransport
automatisieren soll. Das ist ein bisschen gefährlich.
Eine Pumpe irgendwie und dann einmal einfach
unabsprichtversichert.
Ja, wäre eine Idee
tatsächlich vielleicht.
Genau.
Ja, aber in dem Bereich ist Python halt auch,
glaube ich, sehr stark unterwegs.
Und da, gerade wenn man jetzt
also einmal auf der Serverseite sozusagen
Also das Ding, was diese ganzen smarten, mehr oder weniger smarten Geräte halt sozusagen managt und mit denen da irgendwas macht, irgendwelche Sensordaten ausliest. Die Seite ist Python, aber halt auch die Sensoren selber. Also man kann zum Beispiel, es gibt da so kleine Boards, kosten ein paar Dollar und da ist ein Chip drauf mit ein wenig, ist nicht so schnell und hat auch wenig Speicher, aber da läuft MicroPython zum Beispiel drauf, sodass man da halt...
Nächste Folge. Ja, genau.
Das heißt, man kann auch da Python
drauf laufen lassen und dann
irgendwie Sensordaten damit schon irgendwas machen.
Da muss man aber wieder aufpassen, dass wir die Module
so nehmen, dass sie möglichst klein werden. Genau, da
muss man wieder ein bisschen aufpassen und so, aber
ja, also in dem Bereich ist Python
halt auch sehr, sehr stark
vertreten.
Ja, ich glaube, also was noch dazu kommt, vielleicht so Rapid
Prototyping erstmal nochmal als Basis wird
reingeschmissen. Man kann relativ schnell irgendwelche
Prototypen bauen von Dingen, die
man benutzt, sei es jetzt im Web oder bei Daten, die dann auch
funktionieren, die kurz sind.
Wenn man jetzt zum Beispiel die Sprache vergleicht, ist ja auch sehr
einfach, deswegen eignet sich das besonders gut.
Ist vielleicht am nächsten am
Pseudocode dran, so von dem, was ich so gesehen habe.
Das heißt, man kann relativ einfach
die Syntax formulieren und hat direkt
ein lauffähiges Programm,
was wenigstens so grob das tut,
was es sollte später.
Dazu würdest du sagen,
ist noch so einer der großen Vorteile
der Sprache, wo man jetzt von außen drauf guckt.
Wir sind jetzt nicht so für den Anfängern oder so.
Ja, vielleicht wäre es ganz interessant, das mal so ein bisschen zu differenzieren
gegenüber den anderen Sprachen, die es halt in den ganzen Bereichen
auch gibt, mit denen man auch diese ganzen
Dinge tun kann.
Also Python ist halt,
würde ich sagen, gehört so zur
Familie der
Script-Sprachen irgendwie. Also man könnte sagen, es ist sowas
ähnliches wie Ruby oder wie Perl oder
auch ein bisschen wie JavaScript.
Aber
unterscheidet sich halt, oder PHP,
unterscheidet sich von denen aber. Also wie zum Beispiel
JavaScript und PHP, die sind halt
dynamisch getypt
sozusagen und schwach
getypt.
Sozusagen
Dinge können ihren Typ
ändern oder man weiß nicht, was sie sind
sozusagen von Anfang an.
Das ist in Python auch so.
Aber in Python ist halt
streng getypt.
Auch dynamisch und streng.
Das heißt, wenn ich jetzt sage,
irgendwie eine Zahl plus
irgendwie ein String oder so,
dann kriege ich bei Python
dann halt ein Type Error, also
ein Fehler.
Also ein Fehler.
Da haut mir Python halt auf die Finger,
während in PHP oder in JavaScript
passiert dann halt irgendwas.
Was passiert denn da?
Oder ist das dunkle Magie wahrscheinlich?
Es ist eher dunkel und
man weiß nicht so genau, was dann passiert.
Es kommen die komischsten Sachen, aber es gibt einen schönen
Vortrag
für JavaScript,
das mal jemand, es ist ein bisschen veraltet,
aber hat das mal jemand
aufgeschrieben. Ich glaube, wenn man danach sucht
JavaScript Talk und dann
Watt, W-A-T, dann
findet man das. Und dann, wo er dann so
eben solche Dinge macht, wie
irgendeine Zahl plus Leer-String
und dann kommen halt die seltsamsten Dinge dabei raus.
Oder der Server hüpft und blinkt und
am Schluss kommen irgendwelche Zeichenkenten dabei raus und
Batman erscheint. Also es ist wirklich,
man muss aufpassen, was man da tut, ansonsten passieren
ganz, ganz furchtbare Dinge. Klingt so, als könnte
man das gut ausnutzen.
Ja, und es passieren halt auch regelmäßig wirklich schlimme Sachen.
Die Welt geht unter.
Ja, ja, so ungefähr.
Und das kann bei einem Python halt nicht so leicht passieren.
Das ist schon mal ganz schön.
Also insofern ist es halt in der Welt,
also ich finde, was man über Python sagen kann,
es macht halt die richtigen Trade-offs.
Also es ist halt immer, es ist halt so eine Sache.
möchte man
jetzt, das hat ja natürlich auch Vorteile,
man kann Dinge
vielleicht abkürzen oder so, wenn man das
schwach getypt, wenn man das nicht so streng überprüft,
man kann das teilweise ausnutzen, um Sachen
eleganter zu machen, aber man zahlt halt
einen Preis dafür und
Python hat so die Tendenz, immer diese
richtigen Trade-Offs zu machen.
In der neuen Version, ich weiß jetzt gar nicht, ob das bei 3.7 kam
oder bei irgendeiner 3.6 Version, dann kann man diese Typen
jetzt so schön annotieren noch,
für Funktionen oder für Variablen direkt und
sieht dann, dass direkt das beispielsweise
in seinem Linter oder sowas. Also das, was
den Code unterstreicht, wenn ein Fehler
da ist, dass der Typ falsch ist. Also wenn man jetzt
Standardtypen eher haben möchte
oder feste Typen und keine dynamischen,
dass man zumindest weiß, was da
stehen sollte, obwohl das Python immer noch versucht
zu sprechen. Ja, also aber
das Schöne ist halt, das ist halt optional.
Man kann das da ranschreiben. Also klar,
natürlich, das ist auch einer der Vorteile, die in so einer
Sprache wie Java oder so, die ist halt statisch getypt.
Also nicht dynamisch. Da kann man
hinterher, wenn ich einen Variabler habe,
die ändert sich nicht einfach so,
was einen anderen Typ. Das geht da halt gar nicht.
Und das kann auch nicht sein, dass
hinterher der Typ erst festgelegt wird zur Laufzeit,
sondern das muss halt zur
Compile-Zeit sozusagen, wo der
Source-Code in Bytecode verwandelt wird, muss das halt
feststehen.
Eine schöne Geschichte, die man dann halt
bauen kann, ist halt Unterstützung in den IDEs
dafür. Also wenn ich halt weiß,
sozusagen, dass diese Variable halt den
Typ hat, dann kann die IDE mir schon auf die Finger
hauen, wenn ich versuche, damit etwas zu machen, was halt nicht geht.
Also das bringt auf jeden Fall
einen interessanten Trade-Off, weil als Anfänger würde ich
mir jetzt erstmal so denken, dynamisch
klingt ja voll cool, da kann das immer was Verschiedenes sein
und da kann ich ganz tolle Sachen mitmachen und
du sagst jetzt gerade, der Start ist natürlich auch voll toll, weil man kann
das irgendwie nicht verwechseln und man bekommt keine
Fehler. Naja, der Nachteil dabei ist halt,
da muss man viel mehr schreiben. Was auch nicht
so ein Problem ist, wenn man eine IDE verwendet, weil die
schreibt das dann für einen so ein bisschen.
Aber man braucht
dann halt eine komplizierte IDE, die irgendwie
Dinge tut und dann auch nicht mehr so schnell sein kann.
Also ja, das
ja, also
man kann damit auch programmieren, so schlimm ist es nicht,
aber es ist halt so ein bisschen, ich mag
es nicht so, ich mag lieber, man schreibt
wenig und schreibt es dann halt aber selber
und das
Tool, was man dafür verwendet, ist halt schnell, als
die IDE schreibt das, aber die ist so ein bisschen
laggy und man muss ein bisschen auf die warten.
Ja gut, aber das geht
auch, in Python hat man das jetzt
halt so nicht, das ist alles dynamisch, man kann aber auch
Typ-Annotationen jetzt, das ist
auch eine sehr neue Geschichte, kann man halt halt dazuschreiben
und dann könnte einem die IDE oder
PyCharm und so können das möglicherweise auch schon.
Die kann einem dann dabei helfen und dann auch
sagen, wenn irgendwas nicht geht.
Ich glaube also zum Beispiel
in Listen kann man auch verschiedene Datentypen
benutzen, es sei denn, man benutzt erst NumPyArrays, wo das
dann auch wieder fest ist. Aber ja, das glaube ich
auch ganz interessant, weil es halt sein kann,
wenn man durch so eine Liste iteriert und man macht
irgendeine Multiplikation oder sowas,
dann fliegt einem das um die Ohren, weil das der falsche
Datentyp ist. Das ist genau
einer dieser Geschichten, wo
statisch getypte Sprachen
große Schwierigkeiten mit haben oder
als Programmierer das Leben halt schwer machen.
So diese ganzen Containerdatentypen,
die sind da halt knifflig
oder man kann halt im Grunde immer nur
Container haben, die halt dann
irgendwie Dinge von einem Typ enthalten,
weil man muss ja
irgendwie sagen, welchen Typ die Variable
hat, die man da reintut und das ist halt, also gut,
geht mittlerweile auch, es gibt Generics und
ist inzwischen auch in Java angekommen
und man kann da auch so Sachen machen,
aber das ist alles dann nicht mehr so richtig
einfach und ein
Dingen, was man dann halt oft sieht,
was Leute dann machen, ist, sie haben
halt, naja, also um diese
Unzulänglichkeiten, sag ich mal, so könnte man
das sehen in der Sprache, zu kompensieren,
überlegen sie sich dann halt irgendwie Patterns,
wie man bestimmte Probleme, auf die man dann stößt,
wenn man nicht mehr einfach
quasi beliebige Dinge irgendwie
in ein Ding, was halt über Sachen iteriert, packen kann.
Ja, weil so ein Python-Iterator ist halt,
der iteriert halt über Sachen und da kann halt beliebiges
Zeug drin sein.
Wenn das halt nicht geht, dann
dann muss man sich halt so Patterns
überlegen, wie man Dinge tun kann.
Für viele Situationen kann man
das dann halt nicht einfach so hinschreiben, was man machen möchte,
sondern dann muss man halt, dann gibt es
ein ganzes Gang-of-Four-Buch
irgendwie.
Bitte was? Das ist ein ganz bekanntes Buch
von, naja, wer ist das?
Das wird immer Gang-of-Four-Buch
genannt.
Ja, das musst du unbedingt auch in die Shownotes packen.
Ja, ich glaube, das Ding heißt auch immer Design Patterns
oder so. Und da sind halt
ich weiß nicht, wie viele
das sind, hundert oder irgendwas in den Dreh.
Typische
Design-Patterns, die man halt jetzt in so statisch getübten
Programmi-Sprachen vor allen Dingen verwenden kann,
wenn einem solche Probleme halt plagen,
wie man damit umgeht. Und die das dann halt
hübsch lösen, sozusagen.
Und wenn
man dieses Buch durchgeht
und sich dann überlegt, wie würde ich das in Python machen, dann stellt man halt
oft fest, ich brauche da gar keinen Pattern.
In Python kann ich das einfach so hinschreiben.
Da muss ich mir kein kompliziertes
das Ding ausdenken, mit dem ich halt irgendwie da jetzt
Architektur-Ding, mit dem ich da mit diesem Problem fertig werde,
weil ich habe das Problem gar nicht.
Und das ist halt schon sehr nett, dass man halt
quasi eine große Klasse von Problemen,
die halt, ja, also auch
dieses Buch wurde halt gefeiert als
das kann man irgendwie so programmieren, in die Hand geben
und dann kriegen sie das halt alles hin, wo sie
sich vorher einen abgebrochen haben.
So in Python hat man einen Großteil dieser
Probleme hat man einfach nicht. So loslegen, machen.
Ja. Ja. Und das ist halt
schon sehr schön. Das ist ein großer Vorteil.
Ja, also
Also da würde ich sagen, ist halt auch eine der Stärken von Python,
dass man halt quasi irgendwie einen Großteil der komplizierteren Programmier-Patterns nicht braucht,
weil man kann es einfach so hinschreiben.
Ich meine, klar, natürlich auch in Python gibt es Sachen, die kompliziert sind
und nicht alle Patterns sind überflüssig.
Deswegen, also es gibt durchaus Sachen, die man da auch brauchen kann.
Aber es macht das Leben schon irgendwie leichter.
Ja, das wäre so der Unterschied statisch getypt, dynamisch getypt.
Genau, den strengen Sprach hatten wir jetzt auch schon im Vergleich zu den anderen Programmiersprachen.
Was wir auch noch haben, ist quasi binär kompiliert.
Das hatten wir aber auch eben schon ein bisschen abgehandelt.
Dann gibt es natürlich Sprachen, in denen man das Memory Management selber macht.
So C zum Beispiel.
Da muss man immer so einen Zeiger durch den Speicher schicken, der genau sagt, wo man gerade ist.
Ja, also
genau, also
man alluziert halt irgendwie Speicher und dann kriegt man
einen Zeiger drauf zurück und dann macht man damit irgendwas
und muss halt hinterher dran denken, dass man diese Strukturen
wieder freigibt, wenn man sie nicht mehr braucht.
Oder ja,
wenn man Dinge freigibt, die man
die eigentlich immer noch brauchen,
dann passieren schreckliche Dinge.
Und wie löst man das in Python?
In Python hat man damit nichts zu tun.
Das ist sozusagen
das macht Python
für einen selbst.
Es sei denn, man schreibt wieder so Low-Level-C-Module
oder so, die irgendwelche Dinge tun, dann muss man das auch wieder selber
machen. Aber
wenn man einfach sich in Python
bewegt, dann hat man damit eigentlich nichts zu tun,
weil das passiert dann automatisch.
Python verwendet da ein System, das nennt sich
Reference-Counting.
Also es gibt da auch wieder einen Unterschied.
Also in einer Sprache wie Java
ist es ja auch so, da muss man sich auch eigentlich nicht drum kümmern.
Das macht halt auch der Interpreter.
Und dann gibt es halt noch Sprachen,
die machen Garbage
haben einen Garbage-Collector.
Wie Python?
Ja, also Python hat auch einen Garbage-Collector,
aber ja,
es ist ein bisschen kompliziert leider.
Aber hauptsächlich ist es ein Python
Reference-Counting, sozusagen.
Das heißt, es zählt, wie oft ist irgendwas
irgendwo da und wenn es nicht mehr da ist, dann zahlt es weg.
Genau, wenn irgendwo eine neue Reference entsteht,
dann wird der Reference-Counter hochgezählt
und irgendwie ansonsten,
wenn eine Reference verschwindet, gelöscht wird,
dann wird es runtergezählt und wenn es bei 0 ankommen wird,
wird das Objekt abgeräumt.
Und
das hat
den großen Vorteil,
es ist ziemlich schnell zur Laufzeit
und
es ist
sozusagen auch
sehr einfach, also kann nicht viel schief gehen.
Es sorgt für
vorhersagbare Latenzen.
Es hat aber auch einen großen Nachteil.
Okay.
Der große Nachteil ist,
ja, man kann
dann nicht mehr Paralleldinge machen.
Oh Gott, oh Gott, oh Gott. Also auf unterschiedlichen Prozessoren.
Das geht im Grunde nicht mehr.
Also das könnte man tun, da muss man halt
wenn man es naiv
machen wollte, müsste man dann für jede Operation,
die jetzt irgendwie so ein Reference-Counter
hoch oder runter zählt, da müsste man irgendwie
so einen Lock drauf machen und sagen, so,
jetzt mal alle stopp, wir erhöhen
jetzt diesen Reference-Counter
und dann können alle wieder weitermachen. Wenn man das
tut, wird alles ungefähr 40 Mal so langsam.
Und das geht alles einfach nicht mehr.
Ich glaube, Leute haben irgendwie lange daran gefeilt,
sind jetzt auf Faktor 20 oder so runter,
wo man gar nicht gedacht hätte, dass es überhaupt möglich wäre.
Das heißt, du brauchst 20 Kerne, damit du dann den einen Kern...
Die Performance von einem Kern hinfickst, genau.
Das ist natürlich irgendwie nicht so richtig effizient.
Also das ist natürlich ein großer Nachteil.
Und dafür gibt es halt bei Python auch den Global Interpreter Log.
Den bitte was?
Ja, GIL oder Global Interpreter Log.
Das ist sozusagen ein Ding, was dafür sorgt,
dass quasi ein Python-Prozess nur auf einer CPU läuft
und nicht ein Python-Prozess auf mehreren CPUs laufen kann.
Das ist halt so.
Also das ist auch der Grund, warum Java das nicht macht.
Java hat einen Garbage-Collector und hat dann dieses Problem nicht.
Das kann dann halt auf mehreren Prozessoren laufen, problemlos.
Oder, naja, problemlos, aber geht.
Und sozusagen muss dann halt ab und zu mal aufräumen.
Dafür ist dieser Garbage-Collector.
Das heißt, auf einmal gibt es eine Pause.
Nee, der Müllteil ist voll.
Jetzt muss der Müll aus, muss erstmal alles einsammeln und wegfahren.
Genau, das Problem ist, man weiß halt nie genau, wann der zuschlägt.
Und das bedeutet halt, wenn man einen Server laufen hat,
dann kann es halt sein, dass man irgendwie plötzlich,
alle Requests sind super schnell und dann plötzlich einer dauert so lange.
Also jetzt, um bei dem Müllauto Beispiel zu bleiben,
kann man nicht einfach messen, wie voll der Müllcontainer ist
und dann irgendwie den Müllwagen so gut fahren lassen,
dass der ein Routenmanagement macht und da richtig vorbeifährt
und die Sachen rechtzeitig lädt, bevor die vollgelaufen sind?
Ja, aber das Problem ist halt, du musst irgendwann...
Weiß nicht, wie viele Leute die Müll essen
und wie viel Müll die wegschmeißen immer, oder?
Ja, ja, ja, also da wird auch eine ganze Menge gemacht
und es funktioniert auch alles irgendwie so ganz okay,
aber das Problem wirst du im Grunde nicht los.
Du hast immer das Problem, dass wenn der Müll weggebracht werden muss,
musst du allen sagen, so, jetzt mal stopp,
jetzt muss erst mal der Müll weggebracht werden.
Aber die schmeißen alles in dieselbe Mülltonne.
Ja, und
dann, ja, selbst wenn
das sehr schnell ist, kann es halt sein, dass es, weiß ich nicht,
200 Millisekunden dauert oder sowas.
Könnte man nicht einfach eine kleinere Mülltonne machen? Hatte für jeden so eine kleinere
Mülltonne, als wenn man so eine große hat?
Ja, ich weiß es nicht.
Aber dieses Problem ist nach wie vor
da, also nach wie vor
kämpfen da Leute mit. Sagen wir mal, das ist halt
einer der Trade-offs. Wenn du halt einen Garbage-Collector
hast, dann kannst du halt
irgendwie Sachen auf mehrere Prozessoren verteilen, aber du hast halt den
Nachteil, dass deine Latenz so ein bisschen
unvorhersagbar wird.
Ja, das ist halt blöd.
Und ja, das
sind halt,
man kann sich halt überlegen, was man irgendwie
lieber mag, sozusagen. Und auch
da finde ich, dass Python dann eine ganz
gute
Wahl getroffen hat mit dem Reference-Counting.
Und auch da gibt es halt den Garbage-Collector, den gibt es halt
vor allen Dingen dafür, dass, wenn jetzt so zirkuläre
Referenzen irgendwie, also wenn das
eine Objekt hat, das auf ein anderes
verweist, das auf ein anderes verweist, das eine Referenz auf ein
drittes hat und das wieder auf das erste oder so, dann
die Katze beißt sich in den Schwanz.
dann werden die durch Reference-Counting nicht weggeräumt
und dann muss auch Python ab und zu mal
einen Garbage-Collector anschmeißen, um solche Sachen zu finden und dann
rauszuwerfen. Aber den Garbage-Collector kriegt man
bei Python mit so etwas wie Import-GC dann?
Ja, genau.
Und der macht manchmal auch blöde
Sachen und auch da hat man dann halt manchmal so die Probleme,
die man von anderen Programmiersprachen kennt. Also wenn man zum Beispiel
ich weiß nicht, ob das heute noch so ist, aber
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 Import-Export-Skripte
auch geschrieben und
da war halt so einer der Tricks halt, dass man
quasi, bevor man halt
so ein paar Millionen Zeilen irgendwie gelesen hat
und die irgendwo reingeschrieben hat in irgendeine Hauptspeicher-Datenstruktur,
dass man halt einmal den
Garbage-Collector ausgeschaltet hat,
dann hat man den ganzen Scheiß importiert und dann hat man
ihn wieder angeschaltet.
Weil ansonsten schlägt
er halt alle paar tausend Zeilen oder so zu
und blockiert alles
und das macht es halt dann irgendwie direkt
ein paar Faktoren schneller oder so.
Heute kann sein, dass heute alles nicht mehr nötig ist
und es besser geworden ist.
Da wäre ich jetzt neugierig,
müssen wir vielleicht auch mal rausfinden,
ob das wirklich noch so ist.
Wenn man das wirklich immer machen muss,
dass man dem Müllwagen sagen muss,
nee, heute nicht.
Ja, genau.
Also wenn man weiß, was passiert,
wenn man sagt, ich haue jetzt die ganze Zeit zurück
in den Hauptspeicher, ich weiß, dass es so ist
und es ist richtig so, da muss nicht geguckt werden,
ob davon was weg kann, weil davon kann noch nichts weg,
weil ich habe noch nichts anderes gemacht,
dann kann ich halt sagen, okay,
da muss der Müllwagen nicht rumfahren.
Das ist der Nachrede.
Aber ist natürlich schon hässlich.
Mit solchen Dingen will man sich eigentlich als Entwickler
ja gar nicht so beschäftigen müssen,
weil das ist natürlich irgendwie
für die meisten Leute alles...
Ja, 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,
ihr findet das alles so interessant wie ich.
Vielleicht kommen wir dann noch ein bisschen
wieder zurück zu dem, 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.
Ja, nee, ich glaube,
im Grunde sind das so die wesentlichen
Unterschiede zu anderen Programmiersprachen.
Ja, ja, okay.
Das heißt, die Unterschiede haben wir jetzt so ein bisschen erklärt,
was man damit alles so machen kann.
Vielleicht wollen wir ein bisschen noch drauf eingehen,
was so die Mythen dieser Sprache sind.
Das ist total einfach.
Das ist immer so einer der Sachen, fand ich jetzt tatsächlich
auch, also von der Syntax her,
dass es sich gut las, dass du nicht
irgendwie da standst und hat es irgendwie wie
ein C, so ein Hello World, wo es dann irgendwie über
mehrere Zeilen geht oder wie in Java, wo dann
erst mal gucken muss, ach, wo geht denn jetzt diese Funktion hin?
Steht da Print Hello World fertig?
Genau, genau. Ja, bei Java
muss man dann erst irgendwie komische,
erst eine Klasse definieren und dann irgendwie
Public, Static, Void, Main oder so was
hinschreiben.
Das sind halt so magische Worte, damit irgendwas passiert.
Aber Python, da schreiben wir einfach Print hin.
Wenn man printen möchte, das ist schon sehr nett.
Ja.
Also bleibt Python denn so einfach?
Ja, nein.
Also, ja, man kann auch...
Kommt auch an, was man damit machen will.
Ja, ja, ja, man kann da auch...
Man kann auch Netzwerkkram damit machen, das hatten wir noch.
Ja, und, ja, genau, und asynchrones Dinge und überhaupt,
ja, da kann es auch dann relativ fies werden.
Das Dumme ist nur, dass es halt dann,
wenn man fiese Probleme hat, dann kann man da nicht viel dran tun.
Dann muss man leider manchmal den sauren Apfel beißen.
Aber ich meine, es ist ja auch schön, wenn quasi schwierige Probleme möglich, schwierige Sachen möglich sind.
Das macht einen mächtigen Tauberstab, also mehr Magie.
Aber es gibt tatsächlich auch Situationen, wo man dann halt auch komplizierte Dinge tun kann bzw. muss.
Und ja, wo es manchmal auch nicht so richtig offensichtlich ist, was Python da tut.
Ja, und es gibt halt auch so Ecken, die halt einfach nicht schön sind.
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 dann relativ hands-on.
Genau, ja, also Mythos ist einfach so, es ist, würde ich sagen, tatsächlich sehr, sehr einfach.
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 das funktioniert halt meistens immer noch, selbst wenn die Antwort, die irgendjemand gegeben hat, 15 Jahre alt ist oder so.
Es gibt tatsächlich auch relativ viele Antworten mittlerweile für Python, das ist auch sehr angenehm.
weil fast 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.
Ja, aber ja, genau.
Also das ist das Python-Einfaches, würde ich sagen.
Das ist ein Mythos, der durchaus irgendwie mehr Wahrheit als ein Mythos ist.
Ja, eine andere Geschichte wäre halt irgendwie,
oh, dieses Significant White Space, das ist ja total furchtbar.
Ich kann so nicht arbeiten.
Für alle Leute, die uns jetzt gerade zum ersten Mal in der Sprache zuhören, bedeutet das tatsächlich, man darauf achten muss, wo was in dem Code steht von Python.
Ja, dass man halt nicht quasi den Code beliebig formatieren kann, sondern dass halt Widespace halt auch zur Syntax gehört.
Also wenn ich eine Zeile, die im gleichen Block ist, anders einrücke als die andere, dann geht das halt schief.
Also das, was ein guter Programmierer
von vornherein formatieren sollte in seinem Code,
das sagt Python, wenn du es nicht machst, dann
stützt es ab und sagt, nee, nee, nee, du, aber nicht.
Ja, genau.
Ja.
Und es ist natürlich doof, wenn man sich so ein anderes Schema
angewohnt hat irgendwann mal. Genau.
Und man kann das halt nicht beliebig einstellen.
Oder wenn man jetzt Tabs und Spaces mixt oder so.
Überhaupt, man kann Tabs
auch verwenden zum Einrücken, aber das sollte man
nicht tun, das ist böse. Immer schön
Spaces verwenden. Vier Leerzeichen pro Ebene.
Und die meisten IDEs,
bauen die 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 Leerzeichen, dann funktioniert das
nicht mehr und ihr seht nicht genau, warum. Weil
irgendwo irgendwelche Leerzeichen dazu
führen, dass 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.
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 darauf achten muss.
Aber das waren halt ein paar Tage und danach war es super
und ich fand das nie wieder problematisch.
Aber ich kann so ein bisschen verstehen,
dass es blöd ist, wenn man das selber dafür sorgen muss,
dass die Formatierung so ist, dass die Syntax stimmt.
Ich würde aber auch sagen,
dass man das heute eigentlich nicht mehr macht.
Andere Sprachen machen ganz viele Klammern oder Semikolon.
Das ist halt der Preis, den man dann zahlen muss,
wenn man eben nicht die Formatierung als Teil der Syntax hat,
sondern sagt, okay, du kannst formatieren, wie du willst.
Dann muss man halt irgendwie anders signalisieren,
wo ein Block anfängt und aufhört.
Und dafür benutzt man halt typischerweise Klammern.
Und das heißt, man hat halt sehr viele Klammern.
Kannst ja mal zählen. Fünf Klammern auf, sechs Klammern zu.
Genau, genau. Und das ist halt auch
nicht so richtig schön. So ein Python ist
diese Frage halt nie so, muss ich da jetzt noch eine Klammer
zu... Doch, man hat sie auch an anderer
Stelle, aber jedenfalls nicht beim
Schließen von Blöcken. So, muss ich da jetzt noch eine Klammer zu
machen oder nicht? Sondern, nee, wenn ich den jetzt
eingerückt habe und aufhöre, dann ist dieser Block vorbei.
Das ist halt viel einfacher.
Ja.
Und 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 denkt, dass es halbwegs passt
und dann nimmt man
halt sowas wie Black, das ist jetzt
ein Ding, was halt... Black?
Ja. Schwarz? Genau.
Das ist so ein
Kommandozeilen-Utility,
das gibt es aber auch als WIM-Plugin für den
Editor oder so und dem sagt man einfach nur
okay, reformatiere alles so, dass
es irgendwie 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 Kommando-Teilen-Tool? Das ist ein
Kommando-Teilen-Tool, aber wie gesagt, es gibt für
die meisten Editoren Plugins, die das dann halt aufmarschen.
Diesen muss ich mir direkt mal aufschreiben hier. Wieder was
gelernt. Genau.
Ja, also ich würde sagen,
heutzutage sollte man eigentlich nicht mehr von Hand
formatieren müssen. Das macht man einfach nicht mehr.
Genau, damit ist das
im Grunde alles kein Problem mehr,
weil
man hat ja als Mensch gar nicht mehr damit zu tun,
und man muss sich keine Gedanken mehr drum machen.
Du kannst den Code in eine Zeile schreiben und es 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 schreiben möchte. Ja, das Semicolon
gibt es auch in Python. Man muss es normalerweise nicht
hinschreiben, weil der Zeilenumbruch, das ist halt
quasi gleiche... Aber wenn man es hinschreibt, tut es nichts.
Aber 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 arglich aus.
Aber für so einen Teleprompter oder so.
Ja, genau.
Ja, also 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 kein Problem mehr eigentlich.
Hier ist gerade der Piep, muss man eine Pflanze gießen jetzt?
Nee, ich habe vergessen,
meiner Uhr zu sagen,
dass sie nicht stören, dass sie nicht rumnerven
soll, deswegen piepst
es bei mir. Ich mache das gerade noch hier
auf lautlos.
Und
eine andere Geschichte ist,
ja genau, Python ist langsam.
Das ist auch immer etwas, was man halt hört.
Oh mein Gott, nein!
Was tue ich jetzt?
Ich bin viel schneller mit...
Man muss das in Go neu schreiben
oder in C oder
C++, viel besser, aber viel schneller.
Und, ist es langsam?
Ja und nein.
Also es kommt halt tatsächlich...
Solche pauschalen
Urteile sind halt
immer falsch eigentlich.
Deswegen, weil man das...
Man muss halt immer
quasi konkret sagen, was man damit meint,
wenn man jetzt sagt, das ist schnell oder langsam
und halt in einem bestimmten Kontext
geben und dann kann man das halt sagen.
Also ich könnte zum Beispiel sagen,
also wenn ich Methoden
aufrufe in Python,
dann 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 in Python.
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++.
Also, insofern, in diesem Kontext wäre Python tatsächlich sehr langsam.
Aber die Frage ist halt, was ein Programm so tut.
Und wenn ich jetzt zum Beispiel große Matrizen mit dem Alter multipliziere
und ich mache das halt irgendwie mit zwei NumPy-Arrays in Python,
wo die Syntax sehr schick ist und ich das in einer Zeile tue
und 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 irgendwelche Datenstrukturen,
weiß ich nicht, irgendwie so ein Type-Memory-View oder
warum immer das ein C, wie man das ein C hält.
Das wird ganz schön ziemlich für die Zeilen lang, ja.
Dann
wird die C-Implementation
deutlich lang, wird halt deutlich langsamer
sein als die Matrizen-Multiplikation
in Python, die halt
man in eine Zeile schreiben kann, wo man einfach nur schreibt
A mal B.
Also C gleich A mal B, ja.
Und das könnte jetzt für
manche Leute überraschend sein, weil
wenn quasi sich jemand
die Mühe gemacht hat, irgendein Problem,
also wirklich 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 gerade diese ganzen Berechnungsgeschichten,
Certificate Computing
Zeugs, das ist halt alles sehr schnell
in Python.
Wie heißt das, C-Types?
Nein, C-Types ist nochmal
eine andere...
Entschuldigt, bitte.
Es ist auch so, dass man quasi
relativ einfach
eine Geschichte, mit der man
dann halt gut optimieren kann,
ist auch sowas wie Sighten zum Beispiel.
Also C-Types ist eher zum Anbieten von
irgendwelchen C-Bibliotheken, aber
es gibt
sowas wie, das haben wir
vergessen, das müssen wir vielleicht gleich nochmal,
es gibt nicht nur den
C-Python-Interpreter,
es gibt auch andere Python-Interpreter
und es gibt halt auch so Dinge wie Sighten, die
Python, beziehungsweise
Python-ähnlichen Code nehmen und
den in C verwandeln.
Ja, also das haben wir ja gar nicht
vergessen, dann erklären wir das doch einfach jetzt. Genau, genau.
Wenn ich jetzt irgendwas schnell
machen möchte, dann gibt es halt die Möglichkeit, okay, ich
schreibe das jetzt einfach in C und
muss mich da ein paar Konventionen
halten, dann kompiliere ich das und dann
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 das in 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.
Und das ist vor allen Dingen halt auch so ein bisschen,
man muss sich da einlesen, wie man so ein
C-Modul schreibt und so.
Aber was man auch
machen kann, ist, man schreibt halt
das, was man auch immer mal machen möchte,
in einem Python-ähnlichen
Dialekt.
Wo man halt auch,
man kann einfach so Python hinschreiben.
Python-ähnlicher Dialekt, das haben wir ja schon ganz viel
Programmiersprache, jetzt gibt es ja nur noch Dialekte.
Also der wesentliche Unterschied ist, dass man
dazuschreiben kann, was die Typen sind, dass man zum Beispiel
schreibt, also dies ist jetzt ein Integer
oder das hier ist ein Float und so.
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.
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 es aber noch nicht.
Jedenfalls, wenn man das jetzt
so hingeschrieben hat, in diesem Dialekt,
sehr einfach ist und aussieht wie Python quasi, mit Typen dran, dann kann man das in C kompilieren
und zwar in C, dass man dann hinterher wieder so kompilieren kann, dass es ein C-Modul ist,
dass man dann wieder importieren kann. So dass man halt das eigentliche C nie so
Man muss eigentlich nur Python, kleiner Dialekt
schreiben und schon ist es C und dann
wird es schnell. Genau, genau. 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 Funktion rein mit
Annotationen 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. Wusch. 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 darauf anlegt, kann man sehr schnell werden.
Auch in diesen Geschichten kann man halt auch
diesen Global Interpreter-Log deaktivieren.
Und 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,
mehrere Prozessoren verteilen.
Passiert auch. Also wenn ich jetzt irgendwie, keine Ahnung,
eben eine Matrizenmultiplikation, 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...
Dask? Ja.
Heißt so...
CTAsk. Dask. Ich weiß gar nicht
genau, wofür das steht. Oder Task.
Statt Dask. Task, nur D.
Ja. Da ist ein Dask.
Ja, okay, lassen wir das.
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
beschneidigen. 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
es einfach drüber und die Funktion wird viel, viel schneller.
Und...
PyPy oder sowas habe ich noch. PyPy, genau, das ist dann
ein anderer Interpreter, den man verwenden kann.
Der hat dann diverse Probleme nicht.
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
es so ein bisschen leidet darunter, dass da nicht so
genug Leute dabei sind.
War es mal aktiv an diesem Projekt?
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 halt 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 verwenden oder so. Also trau niemals den Benchmark,
den du nicht selbst gefälscht hast.
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.
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.
Ähm...
Fällt dir noch was ein?
Ähm...
Warum hat Python so lange
gebraucht, bis es sich so durchsetzte?
Was glaubst du? Das ist eine gute Frage.
Ich hätte damit auch gar nicht gerechnet, dass es jetzt
passiert, dass 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.
Aha.
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, das sind halt
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 es sind sowohl Go wie auch Rust
sind halt sehr viel jünger als Python, insofern
ist es halt
auch vielleicht nicht unbedingt direkt miteinander
vergleichbar, aber
Go ist halt ein schmaleren
Einsatzzweck, würde ich jetzt mal so
denken.
Vielleicht ändert 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
viel CPU braucht. Also wenn man nur Input, Output
machen muss und IOMultiplexen, das geht
mit Python auch total super. Dann nimmt man
ASIC.io oder die neuen
Frameworks, die es da gibt, weiß ich nicht,
Trio da oder
was auch immer.
Frito von David Beasley,
Das war auch sehr toll. Aber ich glaube, das ist nur ein
Dialekt von R-Sync.io.
Ja, genau.
Die sind auch relativ kompatibel 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.
Genau. Ich kann auch mehrere Prozesse
starten oder so. Aber wenn ich jetzt so etwas
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
ja, also, dass ich halt
einen Prozess habe, der halt auf vielen
Prozessoren läuft und dann auch
IOMäß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 noch mal kurz
erklären, es sind bestimmte 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 führt das auch ein bisschen zu weit.
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 und also irgendwas
erzeugt, irgendwas wieder wegschmeißt und
trotzdem quasi der
Prozess, der Speicher des Prozesses, den man
da halt gestartet hat und immer größer wird,
dann hat man halt einen Bug gefunden.
So gibt es natürlich auch immer wieder.
Sollte aber auch nicht passieren in Python.
Aber es gibt da nicht so
harte Garantien.
Und man kann es auch kaputt machen, wenn man
es drauf anlegt. Irgendwelchen Unsinn anstellen.
Einen Gabel-Kollektor importieren, dann drauf referenzieren,
auf die Objekte, die man da findet.
Ja, man kann da beliebig kaputte
Sachen natürlich machen.
Genau.
Ja, aber
in diesem 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, das ist der richtige Schritt sozusagen
oder ich finde, das ist ein sehr
netter Punkt quasi.
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 skalierbar 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.
Dieser Anwendungsfall trifft ja nur
einen kleinen Teil. Spieleprogrammierer.
Spieleprogrammierer und unter Umständen
Leute, die einen Datenbank-Server schreiben
oder einen Web-Server, nicht mal.
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
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. Single-Thread-Performance
ist nicht gut.
Also das, was halt die meisten Leute interessiert,
wenn sie jetzt irgendwas starten, ein Programm starten
und das tut dann irgendwas,
das ist halt langsamer.
Das ist halt genau der Grund, warum, wenn ich jetzt
in so einer IntelliJ IDE auf den Kopf drücke,
dann sich das halt irgendwie alles so zäh anfühlt,
weil Single-Thread-Performance nicht so toll.
Und Latenz nicht
vorhersagbar, klingt nicht so schlimm, ist aber in der Praxis
doof, weil manchmal
zur falschen Zeit
irgendwie, wenn man mehr Latenz braucht, kann halt
sein, dass es halt unter Umständen sehr teuer wird.
Je nachdem, was man da für Services
betreibt.
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
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
das dann oft sehr kompliziert wird
und man halt auch
ordentlich locken muss und
ja, wirklich sich vorzustellen,
was passiert, wenn
ein Prozess auf mehreren CPU-
parallel unterschiedliche Dinge tut,
das ist
einfach für die
allermeisten Programmierer überfordert.
Mich überfordert das total.
Du kannst nicht einfach multidimensionale Matrizen
in deinem Kopf schungieren.
Ja, also
das ist so. Und wenn man jetzt
sozusagen etwas, was
zu schwierig für die meisten Leute ist und selten
gebraucht wird, sagt,
das ist etwas, auf das optimieren wir hin,
dann ist das irgendwie einfach, naja, ich weiß nicht,
ob das so sinnvoll ist.
Wenn ihr anderer Meinung seid,
schreibt eine E-Mail an
handels-pipeline-podcast.de
Ich bin schon gespannt.
Das ist jetzt nicht die reine Wahrheit,
sondern es ist natürlich sehr gefärbt.
Ich mag halt Python, aber
ja.
Ich finde, die haben da einfach einen sehr schönen
Sweet Spot, quasi.
Klingt, als ist das eine Sprache,
die auch zukunftsträchtig durchläuft ist.
Achso, hatten wir eigentlich das
Zen auf Python schon?
Nein, das haben wir noch nicht gemacht.
Das wäre jetzt tatsächlich am Ende der Mythen noch der Punkt.
Vielleicht sollten wir das noch mal kurz...
Denn auf Python, das hört sich ja sehr philosophisch an,
so ein bisschen nach fernöstlicher
Philosophie.
Wir rufen es gerade auf und
möchtest du es tatsächlich zitieren?
Ich denke schon, tatsächlich.
Man kann sich das auch selber angucken, wenn man einfach
so Python startet, einfach Python eingibt
und dann sagt import this,
dann
erscheint das und das
bringt halt so ein bisschen zum Ausdruck, was
so Python
besonders macht oder
wie man Dinge in Python tut und wie sie vielleicht
ein bisschen anders sind, als man das normalerweise vielleicht gewohnt ist.
Und
ja, da sind halt eben
solche Dinge
drin, ich weiß nicht, stimmt, die alle durchgehen,
muss man vielleicht nicht, das ist halt
besser als...
Das steht auch am Anfang von der
Pep-Version,
kann das auch sein? Also von dem Style-Guide,
den es für Python auf der offiziellen Seite gibt.
Ja, weiß ich nicht so genau, aber kann gut sein.
Ja, dann halt solche Sachen wie explizit ist besser als implizit.
Man merkt auch dem Ding an, dass es so ein bisschen sich halt in viele Punkte
sind so Abgrenzungen Richtung Perl, glaube ich.
Also, ja, einfach ist besser als komplex.
Komplex ist besser als kompliziert.
Ja, flach ist besser als
verschachtelt.
Ja,
Spars, weiß ich jetzt gar nicht, wie ich das im Kontext
übersetzen soll, aber es ist halt
sozusagen
ja, Spars is better than
dense, sozusagen
lieber übersichtlich als
Also nicht alles in eine Teile packen. Genau, genau, sozusagen.
Ja,
Lesbarkeit zählt.
Zwischendurch mal leerzeilen lassen,
Lesbarkeit ungemein. Ja, das ist überhaupt eines
der Designziele bei Python gewesen, dass man das halt
weil Code einfach viel
öfter gelesen als geschrieben wird,
es vielleicht Sinn macht, das darauf zu optimieren, dass man das gut lesen
kann. Also wenn euer Nachbar den Abend aus dem Bett klingelt
und dann noch lesen kann, was er da für einen Tag geschrieben hat,
dann seid ihr vielleicht bei Python besser aufgehoben als
bei anderen Sprachen.
Ja, genau.
Spezialfälle sind nicht speziell genug,
um die Regeln zu brechen,
aber Pragmatismus
besser oder Practicality ist besser
als die reine Lehre, als Purity.
Wie lange schreibst du deine Zeilen?
Ich habe das
letztens erst geändert, glaube ich, auf
130 Zeilen.
Ich glaube, er hat 79, 130, 150
irgendwie so. Ich hatte das ganz lange, also bis
vor kurzem habe ich tatsächlich auch
79 verwendet. Also das für die
Leute, die alte Monitore verwenden, die konnten noch nicht mehr
lesen oder die halt gesharete Terminals verwenden mit
mehreren Seiten, das ist dann 79. Ja, Terminals sind
vor allen Dingen, genau.
Dann ist halt bei
80 Zeichen Schluss und
genau, das wäre natürlich, deswegen habe ich das auch
ganz lange gemacht, aber tatsächlich ist es so, dass
heutzutage hat man diese
Anwendungsfälle fast nicht mehr und
die Monitore...
Die Zeichen kann man meistens besser coden, oder? Also es sieht besser aus
auf seinem eigenen Monitor, oder?
Naja, es ist vor allen Dingen auch, es gibt halt
viele Fälle, wo es halt schwierig wird, wenn man dann immer
quasi nach der Anzahl Zeilen
umbrechen, Zeichen umbrechen
muss, dann muss man halt komisch rumformatieren.
Und dann
lieber schön. Und dann lieber schön.
Und das bricht halt dann diese
Begrenzung. So gerade bei Tests, finde ich, ist es
sehr schwer, das einzuhalten, weil oft
muss man halt lange Testnamen
haben und auch, wenn das
irgendwie sprechend sein soll und gut lesbar sein soll, dann
Im gleichen Namen noch umgebrochen.
Uh, ja. Ja, genau.
Dann kann man eigentlich nicht mehr umrechnen
und dann wird es halt einfach lang.
Daher bin ich jetzt, ich weiß nicht,
130, ich weiß nicht,
wie die konkrete Zahl ist,
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 sich irgendwie gut überlegt
Und ja, genau, was haben wir noch? Ja, genau, Fehler sollten nicht einfach so still weggeworfen werden, sondern sollten immer sichtbar sein.
Also wir haben ja auch ein patent assertion oder sowas, ich weiß nicht, ist das ein besonderes Feature oder gibt es das bei Ansprachen auch alles?
Achso, das ist ein Keyword der Sprache, mit dem man halt überprüfen kann, ob eine Bedingung oder irgendwas wahr ist, was sein sollte.
Und wenn es halt nicht so ist, dann wirft das halt einen Fehler.
Das heißt, man kann einen guten Test konzipieren.
Kann man einen guten Test schreiben, ja.
Genau, ja, Fehler sollten irgendwie nie schnell weggeworfen werden, außer man bringt sie zum Schweigen irgendwie explizit.
ja, wenn man irgendwie
mehrere Dinge zur Auswahl hat,
ja, sollte man
irgendwie der Versuchung widerstehen, irgendwie einfach
zu raten. Es sollte nur
einen und
möglichst nur einen, einen einzigen
offensichtlichen
Weg geben, wie man Dinge
tun sollte. Und das ist
natürlich 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 es auch einen, du kannst es halt irgendwie
so machen, es gibt viele Wege
zum Ziel. 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 die Lesbarkeit
natürlich extrem, weil jeder
schreibt dann halt sozusagen sein Perl-Idiom
und man kann halt nicht
mehr so gut, also bei manchen Leuten
war es so, wenn man das nicht angeguckt hat, dann
Was ist das überhaupt?
Ich meine, teilweise ist es sehr schön. Ich habe auch mal
ein Buch gelesen
von Damien
Conway, ich weiß nicht genau, Higher Order Pearl
oder sowas, auch ganz viele verrückte Sachen
gemacht und sowas habe ich dann mit Begeisterung verwendet
und fand das total toll, was man alles für komplexe
Geschichten irgendwie da in wenig
Zeichen irgendwie unterbringen kann.
Aber ich glaube, ich würde 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, etwa so zwei Stunden später.
Ja, zwei Stunden später ist es halt dann vorbei und das ist
nicht ganz so gut, also es ist nicht optimal.
Das ist irgendwie das, da kann man noch was verbessern.
Zu lange danach gearbeitet, dann steht man morgens wieder auf
Oh, was habe ich gestern da gemacht?
Ja, also das, ja, heutzutage.
Also dokumentiert immer schön euren Code.
In Python könnt ihr damit sogar Dock-Tests machen.
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, aber ich würde eher explizite Tests schreiben.
Und ich würde auch PyTests nehmen.
Es gibt halt auch das eingebaute Test-Framework von Python,
das sich stark an JUnit,
glaube ich, an dem Unit-Testing
von Java irgendwie orientiert hat.
Ich weiß gar nicht, wie das heißt.
Und das ist komisch,
weil es ist halt nicht so richtig Pythonisch,
weil es
halt so die Dinge wie
per Konvention sind halt die
Methodennamen CamelCase und
nicht mit Underscore. Normalerweise
Underscore und da ist aber CamelCase
mit Java und das ist halt, sieht komisch aus.
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 von den Features her,
die können quasi das Gleiche.
Aber du Dock-Testest ja jetzt nicht, oder?
Dock-Test weiß ich gar nicht.
Weil die Dock-Test ja einfach in den Dokumentationen
dann irgendwie die Funktionen testen.
Ich weiß gar nicht, ob das
wie die ausgeführt werden
oder welche Testrunner die dann halt
ausführt. Wenn man den einstellen
kann oder so. Das kann auch alles gut.
Aber
ich würde halt eher als Testrunner
eigentlich immer eher PyTest verwenden.
Ja, ich glaube, PyTest nimmt auch die Dock-Tester mit an
oder so. Das kann gut sein.
Ich habe noch nie Dock-Tests. Aber das ist auch alles
nur geraten. Keine Ahnung, muss man sich mal
angucken. Vielleicht ist auch alles gut.
Aber ich würde auf jeden Fall,
das ist halt auch so eine unoffensichtliche Geschichte,
wenn man vielleicht anfängt, dann denkt man sich so,
ach, ich nehme das eingebaute Unit-Test-Framework.
Die Implementation ist
hard to explain, it's a bad idea.
Also ihr seht schon,
wenn wir jetzt irgendwie anfangen rumzustammeln, dann ist das
alles totale Grütze, was sie da gebaut haben natürlich.
Ja.
Ja, now is better
than never.
Ja, also das Do-It, so ein bisschen das Nike-Prinzip,
also einfach anfangen, machen, Prototyping.
Ob schon, niemals,
vielleicht oft besser
sein könnte als genau jetzt.
Man weiß es aber nicht so genau.
Wenn die Implementation
schlecht zu erklären ist,
ist eine schlechte Idee. Wenn die Implementation
leicht zu erklären ist, könnte es
sein, dass es eine gute Idee ist.
Namespace ist eine total tolle Idee.
Sollte man irgendwie mehr von machen.
Was ist ein Namespace?
Vielleicht musst du das nochmal kurz sagen.
Sozusagen ein,
ja, wie kann man das generell?
Also die korrekte Übersetzung wäre
der Namensraum. Also wenn man
Variable genauso nennt wie die Nachbarvariable,
dann ist es relativ schwierig, die dann irgendwann
auseinanderzuhalten, weil wenn man das eine Kind rufkommt,
entweder beide oder nur eins von beiden oder gar nichts mehr.
Und dann kann man das mit einem Namensraum
prefixen, 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
irgendein Modul-Import-Stern sagt,
dann überschreitet einem das gnadenlos halt
irgendwie Dinge,
die man selber definiert hat vielleicht
oder aus anderen Modulen oder so.
Man kann auch übrigens die ganze Standardbibliothek
überschreiben, wenn man einfach den Namen verwendet.
Ja, kann man alles machen. Es gibt auch Leute,
die dann, um das zu umgehen, 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
ganz gut.
Ja.
Sehnen auf Python haben wir jetzt so ein bisschen
den Zuhörern auch noch näher gebracht.
Also was man darunter so ein bisschen versteht.
Wie man, ich sag mal, einen ganz besonders
entspannenden Python-Code schreibt und wie man
da richtig rangeht. Also tatsächlich müsst ihr es
nicht zu komplex machen. Ich glaube, die einfache Lösung
ist besser. Keep it short and simple.
Ja. Das ist, glaube ich, immer eine gute
Idee. Auch unabhängig von Python.
Aber dadurch wird es
halt sehr lesbar und sehr korrigierbar.
er könnte auch sehr gut damit kooperativ arbeiten
mit anderen, weil er, glaube ich, relativ schnell
verstehen wird, was die da denn so getan haben.
Ich meine, auch da gibt es Ausnahmen, aber...
Das kann auch sein, dass das die...
Das weiß ich nicht, ob es immer gut ist, wenn man schnell
versteht, was andere da getan haben. Das könnte auch zu...
Ja...
Wie das bei Douglas Adams
oder so irgendwie
als der Babelfisch eingeführt wurde und alle sich plötzlich
verstanden haben, dass es den schlimmsten
Krieg ever oder keine Ahnung...
Ja, das MRT hat da so ein paar lustige Sachen eingeführt,
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.
Hm, naja.
Ja,
Alter Ego
heißt das Ding. Ach, okay.
Da wird auch noch eine Menge
interessante Dinge passieren,
glaube ich.
Aber ansonsten, ich weiß nicht genau, sind wir
so ein bisschen durch mit der Einführung, glaube ich.
Ja, ich würde tatsächlich sagen, wir sind langsam am Ende der ersten Folge
angekommen. Wir haben es quasi fast
geschafft. Also, was haben wir jetzt gerade schon gemacht?
mal Zen auf Python kennengelernt,
ein kleines bisschen an die Einführungstools gegeben,
so ein bisschen die Features der Sprache uns
angeschaut, irgendwie.
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 findet 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 Modulibritik 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.
Jochen wird bestimmt
was dazu erzählen können.
Und ich stelle ihn blöde Fragen.
Vielleicht schließen wir noch ein bisschen
mit Veranstaltungshinweisen.
Wir sind jetzt in Düsseldorf, also wenn ihr
selber Veranstaltungshinweise habt, dann
sagt doch bitte einer gerne Bescheid, dann
können wir auch eure Veranstaltung jetzt im deutschsprachigen Raum
gerne promoten und hier vorstehen.
Bei uns ist 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 Warteliste ist schon
voll, aber er ist, glaube ich, zweimal im Jahr.
Die gibt es bei Meetup oder bei
pi.ddf, also die Düsseldorfer
super tolle Leute, immer ganz viele
spannende 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-at-python-podcast.de
Ja.
Ansonsten genau, was faszinierend ist, es gibt einmal
die Python User Group
Düsseldorf-PyTDF, die halt auch diese
Sprints organisiert. Es gibt
einen Python-Foo, das ist
im lokalen Düsseldorf
Microspace im Chaosdorf. Das ist einmal
wöchentlich, ist deutlich kleiner.
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 dritte Mal ist...
Ja, aber
finde ich, ist auch ganz toll.
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
wie... 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,
das ist vielleicht ein bisschen besser,
weil so 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 immer sehr gut besucht,
wo es häufig um Python-Themen auch geht.
QuantFinance bei Jesu Statistik,
das sind fortgeschrittene Themen auch.
Genau, und dann gibt es die Python User Group Köln,
Paikolonen.
Einmal im Monat gibt es da ein Treffen.
Das ist auch immer
meistens so 20, 30 Leute.
Und es gibt immer interessante Vorträge.
Danach geht man irgendwo essen.
Ja, bei Pai.d.D.F. ist das auch so.
Hm.
Ja, es ist also mehr im Umfeld.
Wie gesagt, wenn ihr irgendwo aus, weiß ich nicht,
Schießmichtod, Wien, München,
von der Ostsee in der Uckermark irgendwas findet,
dann sagt Bescheid.
Stehen wir hier gerne auch vor.
Ja.
Ich kann nur sagen, Jochen, vielen Dank.
Ja, danke Dominik.
Ein bisschen schlauer geworden.
Tja, so schnell kann es 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üss.