WEBVTT

00:00:00.000 --> 00:00:07.200
Ja, hallo liebe Hörerinnen und Hörer. Willkommen beim Python-Podcast. Allererste Folge, allererste Episode.

00:00:07.200 --> 00:00:12.660
Wir wollen euch heute ein bisschen fügen und folgende Fragen beantworten. Was machen wir eigentlich und warum?

00:00:12.660 --> 00:00:17.900
Wie finde ich einen Einstieg in Python? Also, wenn ich Anfänger bin, wie kann ich damit anfangen?

00:00:17.900 --> 00:00:23.080
Und geben ein paar Anfängertipps. Und dann wollen wir noch ein bisschen erklären, wie Python funktioniert.

00:00:23.080 --> 00:00:25.120
Ein paar Mythen über Python klären und so weiter.

00:00:25.800 --> 00:00:35.160
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

00:00:35.160 --> 00:00:40.700
Und ja, Links und zusätzliche Shownotes zur Sendung findet ihr natürlich in den Shownotes.

00:00:40.700 --> 00:00:43.940
Ja, was machen wir eigentlich? Kleine Einführung?

00:00:43.940 --> 00:00:47.680
Ja, genau. Vielleicht können wir uns einfach kurz vorstellen oder so.

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

00:00:51.520 --> 00:00:52.140
Ja.

00:00:52.140 --> 00:00:53.400
Wer sind wir denn? Hallo Jochen.

00:00:53.400 --> 00:00:54.960
Hallo Dominik, genau.

00:00:55.800 --> 00:01:03.820
Mein Name ist Jochen, der die wirklich wunderschöne Anmoderation gerade kam von Dominik.

00:01:03.820 --> 00:01:11.900
Und genau, ja, wir benutzen beide Python und ich höre auch sehr viele Podcasts.

00:01:11.900 --> 00:01:18.180
Und im englischsprachigen Raum gibt es da durchaus einige ganz gute Podcasts, die man da hören kann.

00:01:18.180 --> 00:01:24.320
Aber ja, zur deutschsprachigen gab es immer mal wieder Versuche, aber letztlich momentan, soweit ich weiß, jedenfalls kein.

00:01:25.800 --> 00:01:27.660
Der kontinuierlich aktualisiert wird.

00:01:27.660 --> 00:01:32.520
Und ja, da dachte ich, na gut, wenn es niemand macht, dann kann man das ja vielleicht einfach selbst mal probieren.

00:01:32.520 --> 00:01:39.120
Und ja, dann habe ich mich so ein bisschen herumgefragt, ob es Leute gibt, die das vielleicht auch gerne machen würden.

00:01:39.120 --> 00:01:41.600
Und ja, so sind wir dann zusammengekommen.

00:01:41.600 --> 00:01:44.660
Und ja.

00:01:44.660 --> 00:01:46.100
Wie kamst du zu Python, Jochen?

00:01:46.100 --> 00:01:48.440
Ja, das ist jetzt auch schon eine Weile her.

00:01:48.440 --> 00:01:55.720
Irgendwann so 2000, Anfang der Nullerjahre sozusagen.

00:01:55.800 --> 00:02:06.240
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.

00:02:06.240 --> 00:02:10.800
Und dann wurde mir nahegelegt, die Dinge, die ich da gemacht habe, irgendwie doch eher in Python zu machen als in Perl.

00:02:10.800 --> 00:02:15.720
Und dann habe ich das erst so ein bisschen so gedacht, na gut, ob ich das wirklich toll finde.

00:02:15.720 --> 00:02:23.820
Aber relativ schnell war ich da ziemlich begeistert von Python und mache seitdem eigentlich nur noch Python und kein Perl mehr.

00:02:23.820 --> 00:02:25.520
Du bist schon ein ziemlich alter Hase.

00:02:25.800 --> 00:02:26.180
Ja, das muss man so sagen.

00:02:26.180 --> 00:02:28.760
Ja, alter Sack.

00:02:28.760 --> 00:02:34.460
Genau, und ja, in unterschiedlichen Bereichen habe ich das jetzt schon so verwendet.

00:02:34.460 --> 00:02:42.060
Und daher, ja, denke ich, ist es vielleicht auch ganz, kann ich da auch so ein bisschen was zu erzählen, was man mit Python alles machen kann.

00:02:42.060 --> 00:02:43.940
Ja, deswegen bist du da, Jochen.

00:02:43.940 --> 00:02:47.240
Also ich gehe davon aus, dass du mir alles erklären kannst, was ich an tollen Fragen habe.

00:02:47.240 --> 00:02:48.840
Ich möchte nämlich noch jede Menge wissen.

00:02:48.840 --> 00:02:52.460
Genau, und wie bist du zu Python gekommen?

00:02:52.460 --> 00:02:53.960
Ja, ich bin ein türmischer Rookie noch.

00:02:53.960 --> 00:02:55.460
Ich bin jetzt insgesamt...

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

00:03:04.780 --> 00:03:10.600
Ich habe zwar auch schon damals in der Schule angefangen mit ein bisschen Programmieren und war seit 96 in der Internet-AG.

00:03:10.600 --> 00:03:15.120
Das war damals ganz besonders fancy und habe Webseiten da gebastelt und so ein Krams.

00:03:15.120 --> 00:03:23.280
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.

00:03:23.280 --> 00:03:25.200
Ein Umdrehen von vorne beginnen.

00:03:25.800 --> 00:03:28.780
Und das zu tun, was mir wirklich am Herzen liegt.

00:03:28.780 --> 00:03:31.180
Eigentlich wollte ich nur ein paar Daten analysieren.

00:03:31.180 --> 00:03:33.260
Und ich bin dann über ein Python-Tutorial gestolpert.

00:03:33.260 --> 00:03:34.040
Ja.

00:03:34.040 --> 00:03:37.720
Und nach ungefähr 20 Minuten hat es mich dann irgendwie ziemlich vom Hocker gehauen und erwischt.

00:03:37.720 --> 00:03:40.280
Und ich wusste, dass es genau das ist, was ich in Zukunft machen will.

00:03:40.280 --> 00:03:41.900
Und so bin ich bei Python gelandet.

00:03:41.900 --> 00:03:53.600
Ja, von einfach mal nur ein paar Daten analysieren zu, ja, neue berufliche quasi Herausforderungen.

00:03:53.600 --> 00:03:55.760
Da klopft jemand an die Tür.

00:03:55.800 --> 00:03:59.040
Das ist halt ein Spielzeug in der Hand.

00:03:59.040 --> 00:03:59.540
Mhm.

00:03:59.540 --> 00:04:00.180
Okay.

00:04:00.180 --> 00:04:02.080
Nun gut, ich hoffe, das stört nicht so weiter.

00:04:02.080 --> 00:04:09.720
Ja, das ist auf jeden Fall ein schneller Einstieg gewesen, als wenn das nach 20 Minuten schon geschnackelt hat.

00:04:09.720 --> 00:04:14.500
Wäre jetzt ein bisschen länger gedauert, aber ja, das ist auf jeden Fall eine gute Sache, glaube ich.

00:04:14.500 --> 00:04:15.040
Das war wirklich so.

00:04:15.040 --> 00:04:19.460
Ich kam da rein, habe den ersten Code geschrieben und habe gedacht, ja, genau, das wollte ich dann machen.

00:04:19.460 --> 00:04:20.800
Stimmt.

00:04:20.800 --> 00:04:21.360
Hammer.

00:04:21.360 --> 00:04:25.180
Also das liegt bestimmt auch vielleicht an der Einfachheit der Sprache, aber da kommen wir vielleicht ein bisschen später zu.

00:04:25.180 --> 00:04:25.760
Was für Features?

00:04:25.800 --> 00:04:26.480
Was für Features Python alle hat?

00:04:26.480 --> 00:04:29.540
Ja, vielleicht fangen wir nochmal an.

00:04:29.540 --> 00:04:30.380
Warum machen wir das eigentlich?

00:04:30.380 --> 00:04:31.920
Für wen ist denn dieser Podcast genau?

00:04:31.920 --> 00:04:32.560
Was glaubst du?

00:04:32.560 --> 00:04:34.620
Für eigentlich jede, die sich für Python interessiert, oder?

00:04:34.620 --> 00:04:36.660
Ja, ich denke schon.

00:04:36.660 --> 00:04:43.460
Also das ist halt auch so ein Ding, dass Python momentan halt sehr viel an Popularität gewinnt.

00:04:43.460 --> 00:04:44.860
Also ich meine, das hat es schon immer getan.

00:04:44.860 --> 00:04:53.700
Also es war schon immer recht populär, aber in letzter Zeit gerade eben über Data Science und verwandte Themen,

00:04:53.700 --> 00:04:55.100
Machine Learning, Deep Learning.

00:04:55.800 --> 00:05:00.220
Und Dinge, die halt auch sonst sehr stark gehypt werden, ist Python halt sehr, sehr groß geworden.

00:05:00.220 --> 00:05:08.820
Und mittlerweile hat es halt irgendwie Ausmaße angenommen, die dazu führen, dass es jetzt eine ganze Menge Leute gibt,

00:05:08.820 --> 00:05:10.720
die das gerne lernen würden oder sich dafür interessieren.

00:05:10.720 --> 00:05:17.160
Aber wenig Angebote sozusagen, diese ganzen Leute irgendwie abzuholen.

00:05:17.160 --> 00:05:24.320
Und ich denke, da können wir auf jeden Fall eine Menge Hörer ansprechen, sozusagen.

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

00:05:32.500 --> 00:05:35.140
Wir hatten uns ja auch schon so ein bisschen Gedanken zugemacht, was man da alles mal,

00:05:35.140 --> 00:05:37.780
worüber man, über welche Dinge man mal so eine Sendung machen könnte.

00:05:37.780 --> 00:05:40.340
Und da haben wir auf jeden Fall genug Stoff zu senden.

00:05:40.340 --> 00:05:42.740
Und da können wir auch gerne mal so richtig fies ins Detail gehen.

00:05:42.740 --> 00:05:46.040
Ja, genau. Also ich glaube, bevor wir euch erzählen, was wir heute denn genau so machen,

00:05:46.040 --> 00:05:49.740
wir haben ja einen kleinen Einstieg schon gegeben, gibt es tatsächlich diese ganzen vielfältigen Themen in Python.

00:05:49.740 --> 00:05:53.940
Und wir wollen jetzt tatsächlich in mehreren Episoden euch das ganz Interessante mal so ein bisschen berichten.

00:05:54.600 --> 00:05:59.660
Über Django, über Datenbanken, über Python Performance, über Machine Learning und ein bisschen Data Science,

00:05:59.660 --> 00:06:02.680
MicroPython, es gibt ziemlich einiges, was wir jetzt hier auf dem Zettel haben.

00:06:02.680 --> 00:06:05.300
Können also auch ein bisschen gespannt sein, was wir so machen.

00:06:05.300 --> 00:06:08.420
Ja, was machen wir heute? Das ist der Einstieg in Python.

00:06:08.420 --> 00:06:10.300
Genau, einfach mal so eine Übersicht.

00:06:10.300 --> 00:06:13.640
Genau, und dazu haben wir vielleicht erst mal ein paar kleine Fakten über die Geschichte.

00:06:13.640 --> 00:06:16.560
Dann kann Jochen bestimmt noch viel mehr zu erzählen als ich.

00:06:16.560 --> 00:06:21.040
Aber soweit ich weiß, hat Guido van Rossum die Sprache entwickelt in den frühen 90ern.

00:06:21.040 --> 00:06:24.060
Und zwar aus Amsterdam, das herausentwickelt.

00:06:24.160 --> 00:06:27.500
Ja, also ist schon gute, wie lange?

00:06:27.500 --> 00:06:31.140
Fast 30 Jahre halt, würde man gar nicht denken.

00:06:31.140 --> 00:06:34.180
Python 3, das wir alle nutzen, ist seit 2008.

00:06:34.180 --> 00:06:37.820
Und falls irgendwelche Nachfragen kommen, ja, wir finden nur noch Python 3.

00:06:37.820 --> 00:06:40.940
Ich glaube, das hat sich mittlerweile so eingebürgert.

00:06:40.940 --> 00:06:44.060
Die neueste Version ist jetzt erst im Oktober erschienen, 3.7.1.

00:06:44.060 --> 00:06:47.700
Und für nächsten Herbst ist, glaube ich, 3.8. geplant.

00:06:47.700 --> 00:06:50.720
Also wir sind im Jahr 2018 für alle Menschen, die das irgendwann später...

00:06:50.720 --> 00:06:53.740
Ja, also Jochen, im Laufe der Jahre hat sich ziemlich viel getan in der Sprache, oder?

00:06:54.160 --> 00:06:58.720
Ja, wobei erstaunlich viele Dinge auch recht ähnlich geblieben sind.

00:06:58.720 --> 00:07:02.680
Also ich meine, das ist halt auch möglicherweise einer der Unterschiede zu Sprachen wie...

00:07:02.680 --> 00:07:05.520
Jetzt nehmen wir mal JavaScript oder so, wo sich halt in letzter Zeit sehr viel getan hat.

00:07:05.520 --> 00:07:06.820
Und man dann immer...

00:07:06.820 --> 00:07:11.280
Also ich mache in letzter Zeit auch irgendwie ganz schön viel JavaScript.

00:07:11.280 --> 00:07:13.360
Und oft muss ich dann, wenn ich jetzt irgendwas mache...

00:07:13.360 --> 00:07:20.860
So, wie iteriert man denn jetzt nochmal über irgendwie quasi die Keys und die Values irgendwie in einem Hash oder so?

00:07:20.860 --> 00:07:24.060
Wenn man danach guckt, dann findet man halt...

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

00:07:30.900 --> 00:07:34.320
Und da ist Python eigentlich sehr, sehr stabil geblieben.

00:07:34.320 --> 00:07:35.780
Das ist heute noch...

00:07:35.780 --> 00:07:41.080
Ja gut, an der Stelle hat sich auch tatsächlich was geändert, aber sehr moderat und mehr oder weniger so vorschleifend.

00:07:41.080 --> 00:07:46.660
Das ist halt von Anfang an so, wie es jetzt heute auch noch ist.

00:07:46.660 --> 00:07:50.140
Also es hat sich seit 30 Jahren im Grunde nicht großartig geändert.

00:07:50.140 --> 00:07:54.080
Wobei es da auch nicht so wirklich Bedarf gibt für eine Änderung, weil es war einfach von Anfang an...

00:07:54.160 --> 00:07:55.960
Aber Antupa implementiert.

00:07:55.960 --> 00:08:02.400
Ja, ich glaube, ja genau, 1991 ist das irgendwie gestartet.

00:08:02.400 --> 00:08:06.860
Und ich weiß gar nicht, ob ich da so wahnsinnig viel zu erzählen kann, weil damals war ich auch noch nicht dabei.

00:08:06.860 --> 00:08:09.780
Das habe ich auch alles nicht so richtig auf dem Schirm, was da passiert ist.

00:08:09.780 --> 00:08:10.780
Ich habe irgendwann angefangen...

00:08:10.780 --> 00:08:16.380
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.

00:08:16.380 --> 00:08:18.040
Das muss irgendwann Ende der 90er gewesen sein.

00:08:18.040 --> 00:08:20.200
Da habe ich aber kaum mit Python...

00:08:20.200 --> 00:08:23.740
Also da habe ich nicht wirklich Python gemacht, um Python zu programmieren,

00:08:24.160 --> 00:08:25.680
sondern habe es halt verwendet in irgendwelchen Skripten und so.

00:08:25.680 --> 00:08:27.520
Oder irgendwelche Skripte angefasst.

00:08:27.520 --> 00:08:35.980
Und dann später so wirklich angefangen, damit größere Dinge zu programmieren, habe ich dann mit Python 2.1 oder so.

00:08:35.980 --> 00:08:40.020
Das war die Version, in der ich die erste größere Geschichte geschrieben habe.

00:08:40.020 --> 00:08:42.060
Was würdest du sagen, war so der größte Unterschied zu heute?

00:08:42.060 --> 00:08:46.420
Der Umfang der Standardbibliothek?

00:08:46.420 --> 00:08:50.440
Ja, natürlich, da ist einiges dazugekommen.

00:08:50.440 --> 00:08:54.040
Aber das ist gar nicht so...

00:08:54.160 --> 00:08:56.260
Ja, so was halt...

00:08:56.260 --> 00:09:01.120
Ja, so diverse Sprachfeatures, also Generatoren, ich glaube, die kamen irgendwie mit 2.2 oder so.

00:09:01.120 --> 00:09:07.660
Das ist heute doch etwas, was man viel mehr benutzt, als man es damals getan hat.

00:09:07.660 --> 00:09:11.980
Überhaupt, ja, diverse Keywords, Yield, aber...

00:09:11.980 --> 00:09:13.960
Ja, das stimmt, aber das ist auch schon relativ lange da.

00:09:13.960 --> 00:09:15.640
Also ich weiß nicht, wann 2.2 rauskam.

00:09:15.640 --> 00:09:20.400
Müsste irgendwann 2002, 2003 irgendwann gewesen sein oder so.

00:09:22.820 --> 00:09:31.720
Was heute eine große Rolle spielt, und damals war das halt alles noch gar nicht da, ist alles, was irgendwie mit AsyncIO oder irgendwie, ja...

00:09:31.720 --> 00:09:33.940
Wann kam das anfangen? Version 3, FHRs, oder von 2?

00:09:33.940 --> 00:09:40.140
Nee, nee, die Syntax dafür, also das ist jetzt erst in 3.5, glaube ich, mit dazugekommen.

00:09:40.140 --> 00:09:43.560
Und da hat sich auch noch was zu 3.6 geändert.

00:09:43.560 --> 00:09:45.880
Gab es da vorher ein externes Modul für?

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

00:09:52.820 --> 00:09:54.880
Habe ich auch eine ganze Zeit lang verwendet.

00:09:54.880 --> 00:10:02.980
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.

00:10:02.980 --> 00:10:09.600
Und wenn jetzt jemand anders was geschrieben hat, das auf Twisted, weil ganz viele Leute haben Twisted halt als Basisbibliothek für ihre Netzwerkkram benutzt.

00:10:09.600 --> 00:10:16.860
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.

00:10:16.860 --> 00:10:19.180
Und das war kein so wirklich schöner Zustand.

00:10:19.180 --> 00:10:22.260
Es war auch nicht total furchtbar, das ging alles.

00:10:22.260 --> 00:10:22.600
Und man konnte...

00:10:22.820 --> 00:10:25.800
Also irgendwie mit Threads konnte man auch eigentlich quasi das schon immer machen.

00:10:25.800 --> 00:10:34.620
Irgendwie so IOMultiplexen, das ist halt das, was man vor allen Dingen macht, wenn man jetzt irgendwie quasi so asynchronen Dinge tun will.

00:10:34.620 --> 00:10:36.480
Aber so wirklich schön war das alles nie.

00:10:36.480 --> 00:10:43.540
Und jetzt inzwischen gibt es da halt eine nette Syntaxführer und das ist eigentlich ganz toll und das machen ganz viele.

00:10:43.540 --> 00:10:48.140
Und genau, das war damals alles noch ganz weit entfernt.

00:10:52.480 --> 00:10:55.580
Achso, auch damals, was dazugekommen ist, Newstyle-Classes.

00:10:55.580 --> 00:10:57.500
Was?

00:10:57.500 --> 00:10:59.400
Newstyle-Classes.

00:10:59.400 --> 00:11:00.280
Newstyle-Classes.

00:11:00.280 --> 00:11:03.620
Genau, die Klassen waren etwas anders davor.

00:11:03.620 --> 00:11:08.680
Ja genau, jetzt müsste ich noch nachlesen, was da genau die Unterschiede waren.

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

00:11:20.540 --> 00:11:22.320
Sondern irgendwie die ganze Zeit lang hat man immer...

00:11:22.320 --> 00:11:27.380
Auf Object geschrieben, damit es halt von Object erbt und man Newstyle-Classes automatisch verwendet.

00:11:27.380 --> 00:11:29.480
Was man jetzt halt auch schon eine ganze Zeit lang nicht mehr tun muss.

00:11:29.480 --> 00:11:31.860
Von jeder Klasse automatisch von Object dann, oder?

00:11:31.860 --> 00:11:33.600
Ja, genau.

00:11:33.600 --> 00:11:40.280
Und dann gibt es natürlich noch diverse Meta-Programmierungsgeschichten, Meta-Classes und so.

00:11:40.280 --> 00:11:41.700
Ich weiß gar nicht, wann die dazugekommen sind.

00:11:41.700 --> 00:11:43.520
Das gab es, glaube ich, am Anfang auch nicht.

00:11:43.520 --> 00:11:47.080
Ja, dann...

00:11:47.080 --> 00:11:50.520
Achso, auch eine neue Syntax, die sehr praktisch ist.

00:11:50.520 --> 00:11:51.860
Das ist halt so...

00:11:51.860 --> 00:11:51.980
So...

00:11:51.980 --> 00:11:54.900
Also es gibt List Comprehensions, glaube ich.

00:11:54.900 --> 00:11:55.800
Das gab es auch nicht, seit wann?

00:11:55.800 --> 00:11:57.720
Die gab es bei 1.5 noch nicht.

00:11:57.720 --> 00:11:59.380
Es gab es bei 2.1, sind die, glaube ich, dazugekommen.

00:11:59.380 --> 00:12:04.780
Also jedenfalls, als ich angefangen habe, war das so, das war so eine neue Geschichte, die dazugekommen ist.

00:12:04.780 --> 00:12:06.560
Dann kam, glaube ich, mit...

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

00:12:15.160 --> 00:12:16.960
Das könnte sein, dass das erst mit 2-4 war oder so.

00:12:16.960 --> 00:12:20.960
Und jetzt gibt es auch irgendwie so...

00:12:21.640 --> 00:12:24.060
Syntax für Dict-mäßige Objekte.

00:12:24.060 --> 00:12:34.400
Also man kann halt auch geschweifelt Klammer auf und dann V, K, V in irgendein Dict.items sagen.

00:12:34.400 --> 00:12:35.680
Und dann würde sich...

00:12:35.680 --> 00:12:37.100
Also kann man sich seine Diction erst generieren.

00:12:37.100 --> 00:12:37.940
Ja, genau.

00:12:37.940 --> 00:12:43.140
Und muss dafür nicht extra irgendwie nochmal Dict aufrufen oder so.

00:12:43.140 --> 00:12:44.800
Ja, das ist jetzt...

00:12:44.800 --> 00:12:46.920
Das ist aber dann relativ spät dazugekommen.

00:12:46.920 --> 00:12:48.720
Ich glaube, es ist erst mit Python 2, 3 oder...

00:12:48.720 --> 00:12:49.840
Äh, Python 3 dazu.

00:12:49.840 --> 00:12:50.920
Äh, äh...

00:12:51.640 --> 00:12:52.400
Dazu gekommen jetzt.

00:12:52.400 --> 00:12:54.800
Wofür nützt man denn jetzt eigentlich Python heute?

00:12:54.800 --> 00:12:55.500
Ja.

00:12:55.500 --> 00:12:56.320
Insgesamt.

00:12:56.320 --> 00:13:00.340
Vielleicht machen wir das nochmal als Frage für unsere Hörer, die das so genau wissen wollen.

00:13:00.340 --> 00:13:01.360
Äh, genau.

00:13:01.360 --> 00:13:06.880
Also am Anfang war es vor allen Dingen eine Skript-Sprache zum Verbinden von irgendwelchen Systemen.

00:13:06.880 --> 00:13:07.820
Man hat das halt so...

00:13:07.820 --> 00:13:12.500
Ja, man nennt die Dinge auch Glue-Languages und so, weil man halt...

00:13:12.500 --> 00:13:21.300
Weil es schön einfach ist, diverse andere, ja, in anderen Sprachen programmierte Libraries anzubinden und die dann halt irgendwie miteinander zusammenzubinden.

00:13:21.300 --> 00:13:25.300
Also verschiedene Server-Module mit Python-Kleis dazu geklebt.

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

00:13:37.260 --> 00:13:50.260
Und dann hat man irgendwie eine Bibliothek, die irgendwie Mails macht oder dann kann man irgendwie E-Mails mit Bildern oder so dann irgendwie verknusteln und dann irgendwie...

00:13:51.300 --> 00:13:53.240
Ja, E-Mails mit Bildern drin verschicken oder sowas.

00:13:53.240 --> 00:13:55.500
Und solche Sachen hat man halt in Python vor allen Dingen gemacht.

00:13:55.500 --> 00:14:02.200
Okay, da hat man halt ein Bild in der Hand und man hat einmal ein E-Mail in der Hand und Python gibt dann den Kleber, dass man ein E-Mail mit Bild...

00:14:02.200 --> 00:14:14.360
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.

00:14:14.360 --> 00:14:17.320
Und mit Python kann man das alles sehr schön integrieren.

00:14:17.320 --> 00:14:20.840
Also für sowas hat man es vor allen Dingen verwendet, aber auch für Web-Entwicklung von Anfang an.

00:14:20.960 --> 00:14:23.540
Eigentlich schon, soweit ich weiß...

00:14:23.540 --> 00:14:28.340
Welche Frameworks haben wir da groß? Also ich kenne jetzt zum Beispiel Flask, habe ich in einem Doktor gelehnt, und natürlich Django.

00:14:28.340 --> 00:14:32.360
Ja, die kamen allerdings sehr viel später.

00:14:32.360 --> 00:14:36.540
Also, sagen wir mal so, es wurde halt auch als CGI verwendet.

00:14:36.540 --> 00:14:38.060
Als was?

00:14:38.060 --> 00:14:45.480
Es gab es ganz früher, das ist schon fast ein bisschen Opa als Held vom Krieg-Sektion.

00:14:45.480 --> 00:14:46.740
Ja, das ist ja deswegen natürlich hier.

00:14:46.740 --> 00:14:50.020
Es gab das Common Gateway Interface.

00:14:50.020 --> 00:14:50.740
Das war halt eine...

00:14:50.960 --> 00:14:56.600
...Methode, wie Web-Server sozusagen Skripte aufrufen konnten, die dann irgendwie...

00:14:56.600 --> 00:14:58.120
Also, am Anfang gab es nur...

00:14:58.120 --> 00:15:01.320
Am Anfang waren statische Seiten, wo halt ein Web-Server irgendwie eine Datei ausgeliefert hat.

00:15:01.320 --> 00:15:02.560
HTML pur.

00:15:02.560 --> 00:15:09.840
Ja, und das ist aber ein bisschen wenig, wenn man jetzt also sowas hat wie eine Webseite mit einem Gästebuch.

00:15:09.840 --> 00:15:11.980
Sowas gibt es heute auch alles nicht mehr, aber damals war das halt so.

00:15:11.980 --> 00:15:12.620
Da musste man das haben.

00:15:12.620 --> 00:15:15.000
Da musste man irgendwie einen Encounter haben, der irgendwie...

00:15:15.000 --> 00:15:16.100
Da hat er sein Gästebuch rum und rein.

00:15:16.100 --> 00:15:17.580
Ich war bei dir im Internet.

00:15:17.580 --> 00:15:18.460
Genau.

00:15:18.460 --> 00:15:19.660
Ich habe da was reingeschrieben.

00:15:19.660 --> 00:15:20.540
Ich habe es benutzt.

00:15:20.700 --> 00:15:23.520
Ja, und das geht natürlich mit statischen Seiten irgendwie nicht.

00:15:23.520 --> 00:15:28.140
Also, wenn ich jetzt so ein Gästebuch habe und ich habe da ein Feld, wo ich irgendwas eingeben kann

00:15:28.140 --> 00:15:32.600
und dann soll das halt irgendwo gespeichert werden, dann muss sozusagen der Text, der

00:15:32.600 --> 00:15:36.460
in dieses Feld geschrieben wurde, irgendwie durch ein Skript durch und das muss das irgendwo

00:15:36.460 --> 00:15:36.840
hinschreiben.

00:15:36.840 --> 00:15:43.840
Und damit solche dynamischen Sachen gehen, gibt es halt dieses, damit quasi irgendwie

00:15:43.840 --> 00:15:50.520
der Web-Server mit einem Skript kommunizieren kann, dass man halt irgendwie diesen Kram,

00:15:50.540 --> 00:15:56.500
liest und wegschreibt, gibt es halt das Common-Gateway-Interface und das hat das dann so gemacht, es hat dann halt das Skript gestartet,

00:15:56.500 --> 00:16:01.020
also weggeforkt und dann irgendwie da per Umgebungsvariablen irgendwie die Daten übertragen.

00:16:01.020 --> 00:16:05.800
Das geht, aber es ist halt furchtbar langsam und alles nicht so richtig schön.

00:16:05.800 --> 00:16:08.300
Aber so war das damals.

00:16:08.300 --> 00:16:13.240
Und da, ich erinnere mich auch, dass man da durchaus Python-Skripte, also meistens hat man Perl verwendet,

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

00:16:20.380 --> 00:16:27.380
Und deswegen man keine Python-Skripte als CGI-Skripte irgendwie da angeben konnte, aber...

00:16:27.380 --> 00:16:29.480
Selbst musste man selber hosten, wenn man Python...

00:16:29.480 --> 00:16:31.360
Ja, ja, genau, genau. Insofern war das halt nicht so populär.

00:16:31.360 --> 00:16:37.780
Ja, die ganzen anderen Geschichten, das kam alles viel, viel, viel später.

00:16:37.780 --> 00:16:41.660
Was war denn so das erste Framework, was so mit hochkam, wo man die ersten Seiten vernünftig mit...

00:16:41.660 --> 00:16:44.300
Das gab es für Python, gab es da eigentlich fast nichts.

00:16:44.300 --> 00:16:50.300
Also es gab, also da gab es eigentlich nur PHP, also da gab es ModPython.

00:16:50.380 --> 00:16:51.260
PHP für den Apache.

00:16:51.260 --> 00:16:56.200
Es gab auch einen ModPython, aber das war ziemlich furchtbar, das habe ich mal versucht zu verwenden,

00:16:56.200 --> 00:16:59.200
oder ich habe es sogar eine ganze Zeit lang verwendet, aber das war alles ziemlich scheußlich.

00:16:59.200 --> 00:17:04.400
Hatte MemoryLeaks, war alles irgendwie ätzend, da waren so komische Sachen passiert.

00:17:04.400 --> 00:17:09.820
Also MemoryLeaks heißt dann, der Server stellt ab, wenn den Leute benutzen einfach, wenn die Leute auf dem Server sind.

00:17:09.820 --> 00:17:12.560
Ja, man braucht immer mehr Speicher, man weiß nicht genau warum, und dann irgendwann ist er halt weg,

00:17:12.560 --> 00:17:15.200
und dann muss man halt nachgucken, was da schiefgelaufen ist, und das ist nicht so schön.

00:17:15.200 --> 00:17:18.880
Das ModPython war auch nicht so toll, aber das hat halt so schon irgendwie ganz gut funktioniert.

00:17:20.220 --> 00:17:25.440
Ja, das war so die, auch die Anfang der Nullerjahre war so die große Zeit des sogenannten LAMP-Stacks,

00:17:25.440 --> 00:17:27.440
so Linux, Apache, MySQL.

00:17:27.440 --> 00:17:30.360
PHP?

00:17:30.360 --> 00:17:31.520
PHP, genau.

00:17:31.520 --> 00:17:35.800
Und das hat so halbwegs funktioniert.

00:17:35.800 --> 00:17:44.520
Und ja, Python haben zwar Leute auch quasi als Web-Anwendung verwendet, aber dann immer,

00:17:44.520 --> 00:17:50.080
ach doch jetzt, das Erste, was Leute tatsächlich da in Python gebaut haben,

00:17:50.080 --> 00:17:51.220
war Soap.

00:17:51.220 --> 00:17:52.200
Soap.

00:17:52.200 --> 00:17:54.480
Ja, oder Soapy, ich weiß gar nicht genau, wie man das ausspricht.

00:17:54.480 --> 00:17:55.080
Da gibt es das noch.

00:17:55.080 --> 00:18:01.360
Das gibt es bis heute, und das ist bis heute irgendwie eine ganz tolle Community, irgendwie.

00:18:01.360 --> 00:18:09.020
Und da gab es dann auch so ein Content-Management-System, oder irgendwie so ein Ding, was drauf aufgesetzt hat,

00:18:09.020 --> 00:18:09.720
das nannte sich Plone.

00:18:09.720 --> 00:18:12.120
Also daran erinnere ich mich auch, und das muss irgendwie 2004 gewesen sein,

00:18:12.120 --> 00:18:13.240
als ich das zum ersten Mal ausprobiert habe.

00:18:13.240 --> 00:18:19.080
Das war alles sehr nett, es war nur furchtbar langsam, aber ansonsten war es alles sehr schick.

00:18:19.920 --> 00:18:26.280
Und ich glaube, das waren so die Ersten, die so irgendwie komplexere Web-Anwendungen in Python möglich gemacht haben.

00:18:26.280 --> 00:18:29.720
Wie gesagt, manche Leute benutzen das bis heute.

00:18:29.720 --> 00:18:34.560
Dieses Projekt hat ein großes Problem mit dem Umstieg von Python 2 auf Python 3.

00:18:34.560 --> 00:18:39.060
Ich glaube, da ist noch eine ganze Menge Code nicht umgestellt.

00:18:39.060 --> 00:18:46.960
Und ja, jetzt am 1. Januar 2020 läuft ja irgendwie der Support für Python 2 um.

00:18:46.960 --> 00:18:48.100
Der ist ja weit, der hat ja noch Zeit.

00:18:48.100 --> 00:18:49.700
Ja, das ist nicht mehr so wirklich viel Zeit.

00:18:49.920 --> 00:18:51.260
Und keine Ahnung.

00:18:51.260 --> 00:18:54.060
Also vielleicht haben sie das auch mittlerweile geschafft, dass sie da umgestiegen sind.

00:18:54.060 --> 00:18:57.740
Aber ja, das ist ein bisschen blöd für dieses Projekt.

00:18:57.740 --> 00:19:01.620
Ja, aber das waren so die Ersten, genau.

00:19:01.620 --> 00:19:08.580
Und dann kam halt näher dazu, als es eine standardisierte, schöne Schnittstelle gab.

00:19:08.580 --> 00:19:11.600
Also es gab dann diverse Schnittstellen, die auch besser funktioniert haben als CGI.

00:19:11.600 --> 00:19:12.720
Es gab FastCGI.

00:19:12.720 --> 00:19:15.140
FastCGI?

00:19:15.140 --> 00:19:15.980
Ja, genau.

00:19:15.980 --> 00:19:16.700
Das war schneller.

00:19:16.700 --> 00:19:19.600
Das war schneller, da musste der Server das Skript nicht forken,

00:19:19.760 --> 00:19:22.500
sondern da waren da schon so ein paar Skripte gepreforkt.

00:19:22.500 --> 00:19:27.800
Dann konnte man das irgendwie, dann wurden die Daten da halt irgendwie per Interprozesskommunikation irgendwie hingeschoben.

00:19:27.800 --> 00:19:29.220
Und das war alles deutlich besser.

00:19:29.220 --> 00:19:30.340
Das ging halt dann relativ schnell.

00:19:30.340 --> 00:19:32.960
Aber es war auch alles noch ziemlich hässlich.

00:19:32.960 --> 00:19:35.800
Und es gibt dann, ich weiß nicht, wann das passiert ist.

00:19:35.800 --> 00:19:37.900
Das müsste dann so Mitte der Jahrhundert gewesen sein.

00:19:37.900 --> 00:19:44.440
Seitdem gibt es halt Whiskey sozusagen als Schnittstelle zwischen Webserver und Applikation.

00:19:44.440 --> 00:19:47.200
Also sich das so halbwegs standardisiert hat.

00:19:47.200 --> 00:19:49.740
Hört sich nach etwas ziemlich Holzigem zu trinken.

00:19:49.740 --> 00:19:54.680
Ja, also wird aber W-S-G-I geschrieben.

00:19:54.680 --> 00:19:57.900
Es wird nur lecker ausgesprochen.

00:19:57.900 --> 00:20:02.620
Es ist nicht so lecker, wenn man es sich dann tatsächlich anguckt.

00:20:02.620 --> 00:20:04.160
Aber genau.

00:20:04.160 --> 00:20:09.160
Und damit ist dann eigentlich auch schon die große Zeit von Apache als Webserver irgendwie so ein bisschen vorbei.

00:20:09.160 --> 00:20:14.820
Da tauchen dann plötzlich so andere Server auf, die man halt als Applikationsserver häufig verwendet.

00:20:14.820 --> 00:20:19.720
Beziehungsweise man trennt dann eigentlich zwischen Applikationsservern und Web-Servern.

00:20:19.720 --> 00:20:23.560
Wie den Servern, die halt statisch verheizt nach außen ausliefern.

00:20:23.560 --> 00:20:26.340
Oder die so ein bisschen Reverse-Proxy halt vor den Applikationsservern sind.

00:20:26.340 --> 00:20:29.680
Da nimmt man meistens auch nicht Apache, sondern dann sowas wie Nginx.

00:20:29.680 --> 00:20:32.820
Oder am Anfang gab es dann LightHTTPD und so.

00:20:32.820 --> 00:20:37.900
Und heute vielleicht, für heute nimmt man dann irgendwie sowas wie, na, wie heißt der noch?

00:20:37.900 --> 00:20:39.420
Caddy.

00:20:39.420 --> 00:20:45.180
Ein Google-geschriebener Webserver, der sich schön auch mit Let's Encrypt irgendwie verbindet.

00:20:45.180 --> 00:20:49.560
Und dann hat man halt irgendwie ordentliches SSL nach draußen, irgendwie automatisch.

00:20:49.700 --> 00:20:54.960
Man muss da nicht irgendwie, also bei Nginx, also ich habe mich dann beschäftigt, Nginx so weit zu kriegen,

00:20:54.960 --> 00:20:58.920
dass es halt irgendwie beim Test von SSL-Labs irgendwie überall grün und okay ist.

00:20:58.920 --> 00:21:02.200
Das hat mich irgendwie so zwei Tage gekostet und war irgendwie echt aufwendig.

00:21:02.200 --> 00:21:05.660
Und bei Caddy geht das einfach so.

00:21:05.660 --> 00:21:07.840
Das ist schon super.

00:21:07.840 --> 00:21:11.780
Also den verwende ich jetzt mittlerweile auch meistens vor den Applikationsservern.

00:21:11.780 --> 00:21:15.160
Applikationsserver sind sowas wie Junicorn, den verwende ich meistens.

00:21:15.160 --> 00:21:19.220
Oder MewsGI oder UwesGI heißt ein anderer.

00:21:19.680 --> 00:21:27.760
Oder Werkzeug oder da gibt es einige, die man halt verwenden kann.

00:21:27.760 --> 00:21:34.360
Und die sind sozusagen dafür zuständig quasi, dass da drin die Applikation läuft.

00:21:34.360 --> 00:21:38.360
Und die Requests, die halt sozusagen nur von der Applikation beantwortet werden können,

00:21:38.360 --> 00:21:40.100
die gehen halt dann an diesen Server.

00:21:40.100 --> 00:21:46.320
Und ja, die rufen dann halt eben quasi die Applikation mit der entsprechenden API auf.

00:21:46.320 --> 00:21:47.940
Also ich wollte jetzt gar nicht unterbrechen.

00:21:47.940 --> 00:21:49.000
Das finde ich auch super interessant.

00:21:49.000 --> 00:21:49.660
Ich glaube...

00:21:49.660 --> 00:21:51.160
Vielleicht sogar nach eigener Web-Folge.

00:21:51.160 --> 00:21:53.920
Wir sind ja heute, das wollte ich nicht vergessen.

00:21:53.920 --> 00:21:55.800
Ich hoffe, die Anfänger sind jetzt nicht alle schon ausgestiegen.

00:21:55.800 --> 00:21:57.020
In der Anfänger-Folge.

00:21:57.020 --> 00:21:58.020
Ja, ja, ja.

00:21:58.020 --> 00:22:02.360
Da müssen wir noch ein bisschen mehr eingehen darauf, welche Funktionen man mit Python vielleicht noch machen kann.

00:22:02.360 --> 00:22:02.780
Genau.

00:22:02.780 --> 00:22:05.340
Also wir haben jetzt vielleicht einen kleinen Einstieg schon mal euch gegeben,

00:22:05.340 --> 00:22:09.480
was es so an coolen Möglichkeiten heute gibt mit Python und Web-Frameworks.

00:22:09.480 --> 00:22:10.380
Was machen wir noch?

00:22:10.380 --> 00:22:16.460
Genau, das ist heute auch ein wichtiger Teil.

00:22:16.460 --> 00:22:17.720
Glue ist auch noch immer ein wichtiger Teil.

00:22:17.720 --> 00:22:18.840
Ich habe jetzt letztens...

00:22:18.840 --> 00:22:19.640
Also...

00:22:19.640 --> 00:22:24.160
Um vielleicht kurz Werbung zu machen für einen anderen, für einen englischsprachigen Python-Podcast.

00:22:24.160 --> 00:22:27.780
Das war Talk Python to Me, glaube ich.

00:22:27.780 --> 00:22:28.900
Doch, ja.

00:22:28.900 --> 00:22:29.820
Talk Python to Me.

00:22:29.820 --> 00:22:34.060
In der letzten Folge, da ging es um Python 3 bei Facebook.

00:22:34.060 --> 00:22:39.240
Und da erzählt jemand, der halt Python bei Facebook irgendwie macht,

00:22:39.240 --> 00:22:44.380
dass die ganzen Backend-Systeme, die halt irgendwelche Services machen

00:22:44.380 --> 00:22:47.160
oder irgendwie Sachen hoch runterfahren, Sachen deployen,

00:22:47.160 --> 00:22:49.060
das Ganze quasi Facebook...

00:22:49.640 --> 00:22:52.360
Management, Zeugs, das ist halt alles Python.

00:22:52.360 --> 00:22:59.360
Also Frontend ist zwar PHP, aber alles, was sozusagen Services miteinander verbindet

00:22:59.360 --> 00:23:03.280
oder halt irgendwie interne Geschichten macht, das ist halt bei Facebook alles in Python.

00:23:03.280 --> 00:23:05.560
Also natürlich auch YouTube ist in Python.

00:23:05.560 --> 00:23:06.120
Ja, genau.

00:23:06.120 --> 00:23:07.680
YouTube ist so ein bekannter...

00:23:07.680 --> 00:23:09.560
NASA macht viele Sachen mit Python, habe ich gehört.

00:23:09.560 --> 00:23:10.360
NASA, ja.

00:23:10.360 --> 00:23:13.440
Wollte ich Disney-Filme produzieren und...

00:23:13.440 --> 00:23:16.360
Ja, Pinterest auch ist, glaube ich...

00:23:16.360 --> 00:23:19.480
Ich weiß nicht genau, ob die...

00:23:19.480 --> 00:23:21.560
Die waren sogar Django irgendwie.

00:23:21.560 --> 00:23:24.220
Aber auch halt Python hauptsächlich.

00:23:24.220 --> 00:23:28.780
Instagram ist komplett Python eigentlich von der Web-Applikation her.

00:23:28.780 --> 00:23:33.800
Also ja, es gibt auch durchaus im Frontend einige, die da Python verwenden.

00:23:33.800 --> 00:23:35.580
Aber es ist halt im Grunde überall.

00:23:35.580 --> 00:23:43.440
Und ja, also dieses Gluding ist auch immer noch eine sehr, sehr wichtige Geschichte.

00:23:43.440 --> 00:23:48.100
Aber dann gibt es halt einen neuen Bereich seit einigen Jahren, der halt auch sehr, sehr populär geworden ist.

00:23:48.100 --> 00:23:49.440
Das ist halt so ganze Data Science.

00:23:49.480 --> 00:23:52.780
Machine Learning-Gebiet.

00:23:52.780 --> 00:23:56.340
Daten, diese Sensor-Daten-Erfassung.

00:23:56.340 --> 00:23:59.980
Ja, Scientific Computing, dieser ganze Bereich.

00:23:59.980 --> 00:24:04.040
Also das, was man früher in so einem Matlab gemacht hat, würde ich sagen.

00:24:04.040 --> 00:24:08.040
Ja, oder Mathematiker auch.

00:24:08.040 --> 00:24:15.880
Mathematiker hat ja dieses schöne Konzept entwickelt von diesen Notebooks.

00:24:15.880 --> 00:24:19.460
Also das kennt man vielleicht, wenn man jetzt im wissenschaftlichen Bereich ein bisschen unterwegs ist.

00:24:19.480 --> 00:24:23.180
Weil es gibt so Labortagebücher oder so, wo man aufschreibt, was man irgendwie tut und so.

00:24:23.180 --> 00:24:25.660
Also Python, die Jupyter-Notebooks.

00:24:25.660 --> 00:24:27.300
Genau, die gibt es in Python.

00:24:27.300 --> 00:24:36.800
Und bei Mathematik hatte das tatsächlich zuerst sozusagen dieses Feature, dass man halt solche Notebooks halt dann ausführen kann.

00:24:36.800 --> 00:24:40.120
Und dann halt nachvollziehen kann, was da passiert ist, wenn man zu einem bestimmten Ergebnis gekommen ist.

00:24:40.120 --> 00:24:42.020
Sehr, sehr gute Idee halt.

00:24:42.020 --> 00:24:47.600
Hat sich nie so richtig durchgesetzt, weil Mathematiker ist halt proprietär und teuer.

00:24:47.600 --> 00:24:48.600
Und ist auch eine...

00:24:49.480 --> 00:24:51.180
Sehr exklusive Community irgendwie.

00:24:51.180 --> 00:24:53.720
Und hat irgendwie nie so richtig abgehoben.

00:24:53.720 --> 00:24:55.360
Obwohl es eigentlich schon eine sehr schicke Idee war.

00:24:55.360 --> 00:25:04.360
Und dann wurde die halt aufgegriffen von den Leuten, die irgendwie so einen Interpreter...

00:25:04.360 --> 00:25:06.360
Oder man nennt das irgendwie so...

00:25:06.360 --> 00:25:07.760
Rappel...

00:25:07.760 --> 00:25:09.100
Weiß gar nicht, wofür diese Abkürzung...

00:25:09.100 --> 00:25:13.060
Also diese Shell, die man bekommt, wenn man jetzt Python eingibt.

00:25:13.060 --> 00:25:15.420
Du meinst quasi iPython jetzt in dem Fall?

00:25:15.420 --> 00:25:15.860
Genau, iPython.

00:25:15.860 --> 00:25:16.580
Ja, ja.

00:25:16.580 --> 00:25:19.400
Die haben halt sozusagen das da mit reingebaut.

00:25:19.480 --> 00:25:21.200
Und das nennt sich dann iPython Notebook.

00:25:21.200 --> 00:25:26.140
Also iPython hätte schon den ganzen Teil der Funktion, die man dafür braucht, wenn man sowas implementieren will.

00:25:26.140 --> 00:25:32.840
Und iPython Notebook hat dann halt quasi sozusagen die Ideen von diesen Mathematiker-Notebooks irgendwie aufgegriffen.

00:25:32.840 --> 00:25:36.940
Und ja, das war ein toller Erfolg.

00:25:36.940 --> 00:25:38.280
Man hat das dann auch für andere Sprachen gemacht.

00:25:38.280 --> 00:25:41.140
Für R und für Julia.

00:25:41.140 --> 00:25:44.920
Und dann war irgendwie klar, dass iPython Notebook ein blöder Name dafür ist.

00:25:44.920 --> 00:25:49.440
Weil wenn es halt nicht mehr Python ist, sondern auch andere Seelen, dann wurde das halt unbedingt in Jupiter.

00:25:49.480 --> 00:25:51.880
Wobei das halt nicht

00:25:51.880 --> 00:25:58.120
wie der Planet geschrieben wird, sondern mit PY halt wie für Python, weil es Julia, Python, R

00:25:58.120 --> 00:26:02.060
quasi, also die drei Sprachen, die da halt hauptsächlich irgendwie

00:26:02.060 --> 00:26:05.760
verwendet werden. Das sieht ja ganz schick aus, habe ich tatsächlich auch schon ein paar Mal gesehen, das kann man

00:26:05.760 --> 00:26:09.980
tolle Sachen mitmachen und auch live den Code direkt testen, ausführen, was man damit macht. Genau, genau, das ist halt

00:26:09.980 --> 00:26:13.980
super praktisch, das ist natürlich jetzt schwer, das zu umschreiben, jemanden, der

00:26:13.980 --> 00:26:17.880
das nicht kennt, quasi, warum das toll ist,

00:26:18.840 --> 00:26:22.300
es ist halt nur so, gerade bei so... Naja, stellt euch vor, ihr könnt ein Buch lesen

00:26:22.300 --> 00:26:26.180
und habt ja irgendeine statistische Tabelle, die ihr anguckt und ihr könnt live da

00:26:26.180 --> 00:26:30.060
die Daten eintragen, ändern und auch im Schaubild verändert sich direkt mit den neuen

00:26:30.060 --> 00:26:33.860
Datensätzen das, was ihr da braucht, was ihr programmiert habt, der Algorithmus, um

00:26:33.860 --> 00:26:38.200
das darzustellen, könnt ihr direkt live sehen, was da passiert. Ja, das ist eine der schönen

00:26:38.200 --> 00:26:41.760
Geschichten, aber was für mich vor allen Dingen, also ich mache auch viel

00:26:41.760 --> 00:26:45.460
Data Science Geschichten, dass das für mich sozusagen das

00:26:45.460 --> 00:26:48.640
Top

00:26:48.640 --> 00:26:52.180
Feature ist, ist halt irgendwie, so viele der Schritte brauchen eine Menge Zeit, also

00:26:52.180 --> 00:26:55.100
wenn man große Datenmengen hat oder so, kann es sein, dass manchmal, wenn man irgendwas macht,

00:26:55.100 --> 00:26:59.340
dauert das halt eine Stunde, sozusagen, und dann hat man ein Ergebnis,

00:26:59.340 --> 00:27:03.540
irgendeine Berechnung, genau, die man macht, und man trainiert irgendein Modell

00:27:03.540 --> 00:27:07.320
oder so, und das rechnet dann halt irgendwie so eine Stunde vor sich hin, und wenn man das jetzt alles in einem

00:27:07.320 --> 00:27:11.200
Skript hat, so wie man das normalerweise hat, dann hat man irgendwie so, okay, man erzeugt dieses Modell, dann

00:27:11.200 --> 00:27:15.220
macht man da irgendwelche Evaluationen drauf, dann visualisiert man das Ganze, dann macht man da

00:27:15.220 --> 00:27:18.060
irgendwelche Tests oder einen möglichen Tragen.

00:27:18.440 --> 00:27:21.500
Die ganze Arbeitsschrittkette durchgehen, bis man wieder an dem Punkt ist, den man gerade geändert hat.

00:27:21.500 --> 00:27:25.000
Genau, man kann das natürlich dann irgendwie schlau cachen, das habe ich früher dann so gemacht,

00:27:25.000 --> 00:27:28.680
da habe ich dann irgendwie Dekoratoren benutzt, die dann halt den Kram immer

00:27:28.680 --> 00:27:33.260
irgendwo hingeschrieben haben in ein Verzeichnis, und dann sozusagen immer wieder

00:27:33.260 --> 00:27:38.240
nur die Arrays, die dabei entstehen, halt wieder zurück, aber das ist halt

00:27:38.240 --> 00:27:41.340
alles nicht so, also das kann man machen, aber diesen Aufwand treibt man auch nur

00:27:41.340 --> 00:27:44.280
dann, wenn man sich sicher ist, dass man das wirklich braucht und dann verändern will,

00:27:44.280 --> 00:27:48.240
und jetzt möchte man halt am Schluss dieser Kette, die halt irgendwas erzeugt, irgendwie eine Funktion

00:27:48.240 --> 00:27:52.420
schreiben, die irgendwas mit den Daten macht, und dann baut man da einen blöden Fehler rein oder so,

00:27:52.420 --> 00:27:57.560
und das passiert einem tatsächlich, wenn man, wenn man, wenn man das jetzt so, wie ich das auch

00:27:57.560 --> 00:28:01.500
früher gemacht habe, passiert einem das relativ häufig, dass man dann halt den Fall hat, dass

00:28:01.500 --> 00:28:05.080
irgendwie, es geht irgendwas schief, man sieht einen Trace weg und denkt sich schon so, oh nein,

00:28:05.080 --> 00:28:09.380
was für ein blöder Fehler, und das Ergebnis von irgendwie einer Stundeberechnung oder so ist weg,

00:28:09.380 --> 00:28:12.360
und man muss halt im Grunde nochmal eine Stunde warten, also selbst wenn man nur ein paar Minuten

00:28:12.360 --> 00:28:17.560
warten muss, ist es halt voll blöd, weil es diesen, man ändert irgendwas, probiert es aus, Zyklus

00:28:18.040 --> 00:28:24.020
aus, wenn, wenn, wenn, wenn da viel Latenz drin ist, dann wird man sehr langsam, und dieses Problem

00:28:24.020 --> 00:28:29.280
löst Jupyter eigentlich, lösen die Jupyter-Notebooks komplett, weil da ist es halt so, dass man jede

00:28:29.280 --> 00:28:32.100
Zelle getrennt ausführen kann, und wenn man jetzt eine Funktion geschrieben hat, die einen Fehler

00:28:32.100 --> 00:28:36.820
enthält, und führt die halt aus auf den Daten, die man jetzt da irgendwie eine Stunde lang berechnet

00:28:36.820 --> 00:28:40.440
hat, und es geht schief, dann ändert man die Funktion, führt sie nochmal aus, und alles ist

00:28:40.440 --> 00:28:43.800
gut, weil, und das Ergebnis ist halt nicht weg, und das ist halt, das ist halt super.

00:28:43.800 --> 00:28:47.760
Wenn man sowas arbeiten möchte, ist das, glaube ich, genau, und das, das, das macht einen halt viel, viel schneller,

00:28:47.840 --> 00:28:49.620
und das ist, das ist halt total toll.

00:28:49.620 --> 00:28:53.000
Also ist das auch für Anfänger sehr gut geeignet, würdest du sagen, auch zu lernen, der Sprache, ja?

00:28:53.000 --> 00:28:56.880
Ja, ja, weil es, weil es halt so schön interaktiv ist, also es ist, man kann einfach eine ganze Menge ausprobieren,

00:28:56.880 --> 00:28:58.920
ohne, dass man jetzt irgendwie

00:28:58.920 --> 00:29:03.400
Editor lernen muss, und ohne, dass man irgendwie quasi wissen muss,

00:29:03.400 --> 00:29:07.860
also das, ja, man kann halt einfach direkt was ausprobieren, wenn es halt schief geht, dann ändert man

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

00:29:11.980 --> 00:29:15.540
ich glaube, das ist ja gar nicht so schlecht, also wenn ihr Fragen habt, natürlich direkt irgendwie an hallo

00:29:15.540 --> 00:29:17.640
at pythonpodcast.de, einfach

00:29:17.640 --> 00:29:21.820
stellen, dann erklären wir euch auch alles, was ihr gerade vielleicht noch nicht verstanden habt, oder was euch ein bisschen zu schnell

00:29:21.820 --> 00:29:25.640
ging. Vielleicht mit ein paar Tipps anfangen, ich glaube, also

00:29:25.640 --> 00:29:29.680
ganz wichtig ist natürlich die offizielle Dokumentation, Aussage des Food zum Lesen, ich glaube,

00:29:29.680 --> 00:29:33.640
da findet man so die meisten Erklärungen für die Standardbibliothek, wie das alles so funktioniert,

00:29:33.640 --> 00:29:37.420
außer von den Tutorials, die es jetzt gibt. Ich habe zum Beispiel mit

00:29:37.420 --> 00:29:41.640
Python the Hard Way angefangen, und das Buch von Seth Torr gelesen, war ein ganz guter Einstieg,

00:29:41.640 --> 00:29:45.980
ja, wenn man sich da so durcharbeitet, kommt man relativ tief in die Materie rein,

00:29:45.980 --> 00:29:47.440
es gibt noch Automated

00:29:47.440 --> 00:29:49.300
Boarding Stuff with Python,

00:29:49.300 --> 00:29:51.700
geht auch auf deutschem Buch zu, das kostet dann leider Geld,

00:29:51.700 --> 00:29:53.180
ansonsten ist das ein kostenloses Tutorial,

00:29:53.180 --> 00:29:55.380
ja, die ganzen Tutorials gibt es sonst bei uns nicht,

00:29:55.380 --> 00:29:57.160
auf Datacamp, Udemy, Udacity,

00:29:57.160 --> 00:29:58.540
unzählige kostenlose,

00:29:58.540 --> 00:30:01.340
ja, du hast ja gerade gesagt, anfangen

00:30:01.340 --> 00:30:03.460
vielleicht mit Jupyter Notebook oder auch einem einfachen

00:30:03.460 --> 00:30:05.460
Text-Title, also ich kann jetzt nicht empfehlen,

00:30:05.460 --> 00:30:07.440
direkt mit einer großen Entwicklungsumgebung zu starten,

00:30:07.440 --> 00:30:09.700
das hält dann erstmal so ein bisschen auf,

00:30:09.700 --> 00:30:11.520
dann gibt es ja dann irgendwann später

00:30:11.520 --> 00:30:13.160
ganz viele tolle Editoren,

00:30:13.160 --> 00:30:14.780
PyCharm, Idle, PowerScore,

00:30:14.780 --> 00:30:16.120
BI, Atom, MX,

00:30:17.240 --> 00:30:17.700
was benutzt du?

00:30:17.700 --> 00:30:19.440
BI,

00:30:19.440 --> 00:30:22.820
ja, das ist,

00:30:22.820 --> 00:30:25.220
ich benutze aber auch PyCharm zum Beispiel

00:30:25.220 --> 00:30:26.760
mittlerweile, weil mich nervt, dass es halt

00:30:26.760 --> 00:30:29.040
doch relativ langsam ist, und

00:30:29.040 --> 00:30:30.860
ja, das ist

00:30:30.860 --> 00:30:31.860
immer bei diesen,

00:30:31.860 --> 00:30:35.180
eigentlich ist das schön, also diese ganzen IntelliJ

00:30:35.180 --> 00:30:36.660
EDEs,

00:30:36.660 --> 00:30:39.040
das ist alles schon sehr nett gemacht, die können auch

00:30:39.040 --> 00:30:40.640
sehr viel, aber

00:30:40.640 --> 00:30:43.080
die reagieren nicht so instantan,

00:30:43.080 --> 00:30:44.920
also es ist immer, wenn man irgendwo draufdrückt oder so, dann

00:30:44.920 --> 00:30:46.540
muss man erst mal, es ist so,

00:30:47.040 --> 00:30:48.720
zu langsam, es ist einfach zu langsam,

00:30:48.720 --> 00:30:50.520
es ist nicht, es ist nicht so,

00:30:50.520 --> 00:30:52.120
es fühlt sich halt nicht so

00:30:52.120 --> 00:30:55.060
snappy irgendwie ordentlich

00:30:55.060 --> 00:30:56.960
an, wie sich halt so ein Profi-Werkzeug anfühlen

00:30:56.960 --> 00:30:59.060
sollte, sondern es fühlt sich halt immer so an

00:30:59.060 --> 00:31:00.880
wie, keine Ahnung,

00:31:00.880 --> 00:31:02.620
wie diese, weiß ich nicht,

00:31:02.620 --> 00:31:04.800
also ich meine, gut, das ist ein böser Vergleich, aber wenn man

00:31:04.800 --> 00:31:06.800
so einen Fahrkartenautomat bei der Bahn steht und

00:31:06.800 --> 00:31:09.040
drückt da drauf, und dann

00:31:09.040 --> 00:31:10.860
passiert einfach nichts, und dann drückt man

00:31:10.860 --> 00:31:12.620
nochmal drauf, aber dann, und dann macht es irgendwie so

00:31:12.620 --> 00:31:14.820
Kennt ihr das, wenn ihr euch gerade so einen

00:31:14.820 --> 00:31:16.840
Toko-Riegel aus dem Automaten ziehen wollt, und dann bleibt der irgendwo

00:31:16.840 --> 00:31:18.760
ja oben hängen? Ja, und das ist

00:31:18.760 --> 00:31:20.100
halt, das ist halt schon sehr,

00:31:20.100 --> 00:31:22.840
so ein bisschen nervtötend, und deswegen benutze

00:31:22.840 --> 00:31:24.860
ich das eigentlich nicht so gern, obwohl manche Features

00:31:24.860 --> 00:31:26.780
halt durchaus so nett sind, dass ich es

00:31:26.780 --> 00:31:28.000
halt auch immer wieder verwende, aber

00:31:28.000 --> 00:31:30.480
wenn ich

00:31:30.480 --> 00:31:32.520
BI verwenden kann, dann verwende ich eigentlich, also

00:31:32.520 --> 00:31:34.880
BIM, da hat sich auch einiges getan.

00:31:34.880 --> 00:31:36.720
Wie, hast du denn Python gelernt?

00:31:36.720 --> 00:31:38.000
Hast du da irgendwie

00:31:38.000 --> 00:31:40.420
Tutorials gemacht, oder warst du da direkt drin?

00:31:40.420 --> 00:31:42.560
War das so basics, dass man alles selber weigen musste?

00:31:42.560 --> 00:31:44.740
Ja, aber es gab nicht

00:31:44.740 --> 00:31:46.460
so viele Bücher,

00:31:46.640 --> 00:31:47.880
damals, es gab ein paar,

00:31:47.880 --> 00:31:50.360
die waren aber auch alle nicht so wirklich hilfreich, also

00:31:50.360 --> 00:31:52.500
doch, es gab ein Buch, das war hilfreich, ich weiß

00:31:52.500 --> 00:31:54.020
aber nicht, ob das immer noch

00:31:54.020 --> 00:31:56.380
eine gute Empfehlung ist, es war das Python-Cookbook,

00:31:56.380 --> 00:31:58.200
das war ganz gut,

00:31:58.200 --> 00:32:00.500
ansonsten

00:32:00.500 --> 00:32:01.960
waren die meisten Bücher nicht so toll,

00:32:01.960 --> 00:32:04.620
und ja,

00:32:04.620 --> 00:32:06.480
ich, wie habe ich es gelernt, also

00:32:06.480 --> 00:32:08.520
ich hatte halt das Glück, dass

00:32:08.520 --> 00:32:10.080
ich da neben ihm gesessen hatte, der das schon konnte,

00:32:10.080 --> 00:32:11.800
und wenn mir das dann gesagt hat,

00:32:11.800 --> 00:32:14.620
ja, das war etwas lukriöse,

00:32:16.440 --> 00:32:17.960
das war relativ praktisch.

00:32:17.960 --> 00:32:20.060
Ja, das kann ich auch tatsächlich auch empfehlen, also versucht nicht nur

00:32:20.060 --> 00:32:21.920
im stillen Kämmerlein zu sitzen und euch selber

00:32:21.920 --> 00:32:24.140
durch den Kram zu quälen, also es geht bedeutend

00:32:24.140 --> 00:32:25.880
schneller, und ihr kommt auch bedeutend schneller weiter, wenn ihr

00:32:25.880 --> 00:32:28.080
tatsächlich jemanden habt, der euch so ein bisschen zeigt, wie das

00:32:28.080 --> 00:32:29.200
Ganze geht. Danke, Jochen!

00:32:29.200 --> 00:32:32.020
Deswegen sitze ich ja hier und stelle dir die ganzen

00:32:32.020 --> 00:32:32.520
doofen Fragen.

00:32:32.520 --> 00:32:35.760
Ja, also genau, man könnte auch

00:32:35.760 --> 00:32:37.940
zu Meetups durchaus

00:32:37.940 --> 00:32:39.880
gehen, sich da mit Leuten austauschen, hilft es.

00:32:39.880 --> 00:32:42.440
Die tägliche

00:32:42.440 --> 00:32:43.940
Arbeit muss man natürlich dann trotzdem machen,

00:32:43.940 --> 00:32:46.180
aber ich glaube, mittlerweile kommt man da ganz gut

00:32:46.240 --> 00:32:48.180
angeleitet auch in die ersten eigenen Projekte so rein.

00:32:48.180 --> 00:32:48.620
Ja.

00:32:48.620 --> 00:32:51.460
Wie funktioniert Python eigentlich?

00:32:51.460 --> 00:32:54.040
Was ist das Ding?

00:32:54.040 --> 00:32:56.300
Wo kann man das machen? Also ich habe jetzt hier zum Beispiel

00:32:56.300 --> 00:32:57.880
auf meinem großen Zettel stehen,

00:32:57.880 --> 00:32:59.580
Simple Prototyping kann man machen,

00:32:59.580 --> 00:33:01.560
und recht umfangreiche Bibliotheken.

00:33:01.560 --> 00:33:03.720
Ja, also

00:33:03.720 --> 00:33:05.880
Python selbst ist halt eine...

00:33:05.880 --> 00:33:07.820
Einfach? Ja. Ist das einfach?

00:33:07.820 --> 00:33:09.900
Es ist ziemlich, ja,

00:33:09.900 --> 00:33:12.100
es verbinden halt zwei Dinge, die sich eigentlich ein bisschen widersprechen.

00:33:12.100 --> 00:33:13.400
Es ist halt sehr einfach, und es ist halt

00:33:13.400 --> 00:33:15.260
trotzdem sehr mächtig,

00:33:16.040 --> 00:33:18.080
das macht es halt sehr schön. Auf der anderen Seite

00:33:18.080 --> 00:33:19.960
bedeutet das halt, dass es nicht so einfach ist, das irgendwie

00:33:19.960 --> 00:33:21.800
in Binärcode zu kompilieren oder so.

00:33:21.800 --> 00:33:24.040
Das ist halt mit einer Sprache, die halt

00:33:24.040 --> 00:33:26.020
wesentlich einfacher sozusagen ist,

00:33:26.020 --> 00:33:27.840
ist das halt simpler. Also wenn man

00:33:27.840 --> 00:33:29.740
C nimmt, C kann man, so ein mehr oder weniger

00:33:29.740 --> 00:33:31.880
Macro-Assembler, da kann man das dafür in den Compiler zuschreiben.

00:33:31.880 --> 00:33:34.120
Warum muss man denn überhaupt etwas in Binärcode kompilieren?

00:33:34.120 --> 00:33:35.860
Ja, wenn es

00:33:35.860 --> 00:33:38.160
ein Computer direkt ausführen können soll,

00:33:38.160 --> 00:33:40.040
dann muss das irgendwie Maschinencode sein.

00:33:40.040 --> 00:33:42.400
Ah, Binärcode, Nullen und Einsen.

00:33:42.400 --> 00:33:44.160
Genau, genau, genau.

00:33:44.160 --> 00:33:46.000
Wenn das so

00:33:46.000 --> 00:33:47.940
etwas ist, dann kann es halt direkt

00:33:47.940 --> 00:33:49.860
ausgeführt werden. Also die meisten Programme,

00:33:49.860 --> 00:33:51.160
die man so kennt, sind das halt auch.

00:33:51.160 --> 00:33:53.840
So wie früher, wenn ich mir das so vorstelle, da hat man diese ganzen

00:33:53.840 --> 00:33:55.940
großen Rechner gehabt, die Lochkarten gelesen

00:33:55.940 --> 00:33:58.000
haben für Nullen und Einsen. Das braucht der Computer

00:33:58.000 --> 00:33:59.860
auch heute noch, damit er versteht, was er da überhaupt machen muss.

00:33:59.860 --> 00:34:01.960
Ja, genau. Und dann läuft halt

00:34:01.960 --> 00:34:03.760
dieses Programm direkt irgendwie

00:34:03.760 --> 00:34:05.340
auf dem Prozessor und

00:34:05.340 --> 00:34:07.780
ja, aber das geht halt,

00:34:07.780 --> 00:34:09.860
das ist halt etwas, was dann nicht mehr geht mit Python,

00:34:09.860 --> 00:34:11.960
weil für Python Compiler zu schreiben

00:34:11.960 --> 00:34:13.260
ist halt dann nicht mehr so einfach.

00:34:13.260 --> 00:34:15.820
Oder eigentlich immer so ziemlich unmöglich,

00:34:15.960 --> 00:34:17.740
weil das ist halt alles dynamisch und zur Laufzeit

00:34:17.740 --> 00:34:19.780
kann sich eine Menge ändern. Das geht halt nicht

00:34:19.780 --> 00:34:21.860
so richtig. Das ist halt in der

00:34:21.860 --> 00:34:23.880
Preis, die man zahlt, dass man es nicht mehr kompilieren kann.

00:34:23.880 --> 00:34:25.640
Es wird dann halt interpretiert.

00:34:25.640 --> 00:34:26.720
Also es wird schon so ein bisschen

00:34:26.720 --> 00:34:29.220
verändert. Es wird in einen Bytecode

00:34:29.220 --> 00:34:31.700
verwandelt und der Bytecode wird dann interpretiert

00:34:31.700 --> 00:34:33.700
von einer virtuellen Maschine. Das sind dann die

00:34:33.700 --> 00:34:35.800
PyC-Dateien, die man findet, nachdem man irgendwas

00:34:35.800 --> 00:34:37.240
gelaufen hat. Genau, genau.

00:34:37.240 --> 00:34:39.820
Also C ist das, was dann das Ganze

00:34:39.820 --> 00:34:41.600
benutzt, um das dann für die Maschine

00:34:41.600 --> 00:34:42.860
schreiblesbar zu machen?

00:34:42.860 --> 00:34:45.920
Ja, aber für die Maschine ist das nicht lesbar.

00:34:45.920 --> 00:34:47.880
Man braucht immer noch den Python-Interpreter,

00:34:47.880 --> 00:34:49.900
der das dann ausführen kann.

00:34:49.900 --> 00:34:51.460
Also, ja, genau.

00:34:51.460 --> 00:34:53.780
Der Python-Interpreter ist halt genau diese virtuelle Maschine

00:34:53.780 --> 00:34:56.180
und der kann das dann halt ausführen.

00:34:56.180 --> 00:34:57.640
Und

00:34:57.640 --> 00:35:00.000
ja, das hat dann auch so einige andere Nachteile.

00:35:00.000 --> 00:35:03.920
Das macht es halt auch schwer, Sachen zu installieren

00:35:03.920 --> 00:35:05.880
oder so, weil man kann

00:35:05.880 --> 00:35:07.440
jetzt nicht einfach irgendwo

00:35:07.440 --> 00:35:09.580
ein Binary runterladen.

00:35:09.580 --> 00:35:10.800
Ich glaube, es gibt da PIP.

00:35:10.800 --> 00:35:13.800
Ja, genau. Dann muss man eben zu so

00:35:13.800 --> 00:35:15.880
Paketmanagern greifen, die

00:35:15.880 --> 00:35:17.580
das hat, mit denen man irgendwelche Dinge installieren kann.

00:35:17.580 --> 00:35:19.720
Aber man kann halt jetzt nicht irgendwie auf dem USB-Stick

00:35:19.720 --> 00:35:20.760
jemandem irgendwie

00:35:20.760 --> 00:35:23.740
Python-Programm geben und der

00:35:23.740 --> 00:35:24.960
startet das dann halt. Das geht halt.

00:35:24.960 --> 00:35:27.520
Wenn ich das richtig verstanden habe, PIP ist dann dieser Paketmanager, der

00:35:27.520 --> 00:35:29.620
über die Seite PyPy oder wie es ist, über den

00:35:29.620 --> 00:35:31.680
Server von dem läuft und dann da

00:35:31.680 --> 00:35:33.780
Pakete installiert, die andere dort bereitgestellt

00:35:33.780 --> 00:35:35.920
haben, die schon damit veröffentlicht

00:35:35.920 --> 00:35:37.640
sind. Das heißt, wenn ihr eure eigenen Pakete

00:35:37.640 --> 00:35:40.000
baut, müsst ihr die entweder so veröffentlichen

00:35:40.000 --> 00:35:41.440
oder tatsächlich

00:35:41.440 --> 00:35:43.560
exzellente Bibliotheken nehmen, um einen Installer zu bauen

00:35:43.560 --> 00:35:45.260
oder sowas. Genau, das gibt es auch.

00:35:45.840 --> 00:35:47.600
Es gibt diverse Geschichten, die das

00:35:47.600 --> 00:35:49.400
dann halt versuchen, irgendwie in Bein und Riech zu packen.

00:35:49.400 --> 00:35:50.880
Und das funktioniert auch manchmal.

00:35:50.880 --> 00:35:53.800
Kannst du kurz zwei, drei Installer

00:35:53.800 --> 00:35:55.540
nennen, die man versucht für verschiedene Systeme? Einmal

00:35:55.540 --> 00:35:57.740
vielleicht für Linux, für OS oder für Windows oder so?

00:35:57.740 --> 00:35:58.900
Ich benutze das selber nie.

00:35:58.900 --> 00:36:01.540
Py2Exe für Windows

00:36:01.540 --> 00:36:03.600
gibt es da irgendwie. Bei Linux braucht man das, glaube ich,

00:36:03.600 --> 00:36:04.020
nicht groß.

00:36:04.020 --> 00:36:09.260
Baust du ein Paket, machst du ein Shell-Install-Setup?

00:36:09.260 --> 00:36:13.400
Unterlegung gibt es auch in so einem Ding, was

00:36:13.400 --> 00:36:15.660
quasi den

00:36:15.800 --> 00:36:17.220
Interpreter mit reinpackt in Binary.

00:36:17.220 --> 00:36:19.160
Kann sein, dass es

00:36:19.160 --> 00:36:19.800
ein Installer ist.

00:36:19.800 --> 00:36:22.380
Wenn man da so ein bisschen

00:36:22.380 --> 00:36:25.580
aufpasst, dann kriegt man

00:36:25.580 --> 00:36:27.160
den Interpreter relativ klein.

00:36:27.160 --> 00:36:29.320
Also wenn man es einfach naiv macht, dann

00:36:29.320 --> 00:36:31.580
kann es sein, dass es so 15 MB

00:36:31.580 --> 00:36:32.400
sind oder 10.

00:36:32.400 --> 00:36:34.860
Man kriegt es auf zwei, drei runter,

00:36:34.860 --> 00:36:37.280
wenn man sich da ein bisschen Mühe gibt.

00:36:37.280 --> 00:36:39.220
Und dann ist es eigentlich, ich meine, heutzutage ist das

00:36:39.220 --> 00:36:40.500
sowieso alles nicht mehr so wild.

00:36:40.500 --> 00:36:43.140
Es gibt natürlich Leute, die sagen würden,

00:36:43.140 --> 00:36:45.760
wenn ich das mit C mache und dann gut

00:36:45.760 --> 00:36:47.020
und nicht gegen die

00:36:47.020 --> 00:36:49.360
Libc-Linke oder gegen die

00:36:49.360 --> 00:36:50.400
G-Libc, sondern halt irgendwie

00:36:50.400 --> 00:36:53.220
so eine Diät-Libc oder irgendwas

00:36:53.220 --> 00:36:53.920
anderes kleines.

00:36:53.920 --> 00:36:59.300
Das sind die Standard-Bibliotheken, die C so

00:36:59.300 --> 00:37:01.240
bereitstellt für die Befehle, die dann das Ganze

00:37:01.240 --> 00:37:02.600
größer machen, wenn man das kompiliert, oder?

00:37:02.600 --> 00:37:05.040
Genau, da ist ein bisschen Standard-Bibliothek dabei, aber eigentlich,

00:37:05.040 --> 00:37:07.220
wofür die da sind, ist die Kommunikation mit dem

00:37:07.220 --> 00:37:08.500
Kernel, mit dem Betriebssystem.

00:37:08.500 --> 00:37:11.140
Und das kann man natürlich auch

00:37:11.140 --> 00:37:13.040
beliebig komplex gestalten, aber wenn man halt

00:37:13.040 --> 00:37:15.320
nur die ganz simpelsten Dinge haben

00:37:15.320 --> 00:37:15.580
will,

00:37:15.720 --> 00:37:18.560
dann muss das nicht so groß sein, weil das Problem ist,

00:37:18.560 --> 00:37:19.940
es muss halt irgendwie dagegen gelinkt sein,

00:37:19.940 --> 00:37:22.600
damit irgendwie der Prozess überhaupt

00:37:22.600 --> 00:37:24.680
irgendwas machen kann, wie Eingabe, Ausgabe und so.

00:37:24.680 --> 00:37:26.640
Aber wenn man das

00:37:26.640 --> 00:37:28.520
schlau macht, dann kriegt man das halt auf, weiß ich nicht,

00:37:28.520 --> 00:37:29.700
ein paar hundert Byte oder so runter.

00:37:29.700 --> 00:37:32.160
Und das ist natürlich was ganz anderes, als wenn ich jetzt irgendwie

00:37:32.160 --> 00:37:33.760
megabyteweise Zeugs...

00:37:33.760 --> 00:37:36.800
Das könnte auch Mikrocontroller packen. Ich glaube, man kriegt das sogar in so einen Bootsektor rein.

00:37:36.800 --> 00:37:39.140
Wie viel hat so ein Bootsektor? 512 Bytes?

00:37:39.140 --> 00:37:40.120
Keine Ahnung, ja.

00:37:40.120 --> 00:37:42.680
Also natürlich

00:37:42.680 --> 00:37:44.600
ist es nicht so klein, wie es gehen

00:37:44.600 --> 00:37:45.680
könnte, wenn man das wirklich

00:37:45.680 --> 00:37:46.900
drauf anlegt.

00:37:46.900 --> 00:37:48.840
Und das wird auch nie gehen

00:37:48.840 --> 00:37:50.260
mit Python so richtig, aber

00:37:50.260 --> 00:37:52.880
also heutzutage sind ja auch ein paar Megabyte

00:37:52.880 --> 00:37:54.920
eigentlich nicht mehr wirklich

00:37:54.920 --> 00:37:55.160
viel.

00:37:55.160 --> 00:37:58.800
Früher war das auch sehr schlimm,

00:37:58.800 --> 00:38:00.020
heute...

00:38:00.020 --> 00:38:02.960
Genau, und

00:38:02.960 --> 00:38:04.840
daher ist das eigentlich auch alles nicht mehr so wild. Aber man muss auch

00:38:04.840 --> 00:38:06.920
sagen, dass dieses Thema so ein bisschen vernachlässigt wurde,

00:38:06.920 --> 00:38:08.280
gerade auf Windows und so,

00:38:08.280 --> 00:38:10.700
da kann man ja auch nicht davon ausgehen,

00:38:10.700 --> 00:38:13.120
also bei den meisten Linux-Systemen wird halt einfach ein Python-Interpreter

00:38:13.120 --> 00:38:14.840
vorinstalliert sein, vielleicht ein uralter, aber

00:38:14.840 --> 00:38:15.240
immerhin.

00:38:15.640 --> 00:38:17.480
Aber bei Windows ist halt Python nicht

00:38:17.480 --> 00:38:19.480
vorinstalliert und wenn man irgendjemandem

00:38:19.480 --> 00:38:21.300
ein Python-Script schickt oder so, kann der halt

00:38:21.300 --> 00:38:23.300
nichts damit anfangen. Das ist ein bisschen

00:38:23.300 --> 00:38:25.400
ein Problem. Das ist halt auch ein bisschen ein Preis,

00:38:25.400 --> 00:38:27.340
den man dann halt zahlt, dafür, dass es

00:38:27.340 --> 00:38:29.460
halt einfach ist, aber trotzdem

00:38:29.460 --> 00:38:30.040
sehr mächtig.

00:38:30.040 --> 00:38:33.400
Und ja, also...

00:38:33.400 --> 00:38:35.360
Die Beine richtig kriegt ihr natürlich trotzdem

00:38:35.360 --> 00:38:36.660
auf der Python-Home-Stage direkt,

00:38:36.660 --> 00:38:39.620
für die jeweiligen Systeme und wenn das...

00:38:39.620 --> 00:38:41.380
Der Python-Interpreter selber ist natürlich wieder

00:38:41.380 --> 00:38:43.340
quasi so ein... Also einige Leute

00:38:43.340 --> 00:38:45.420
empfehlen auch Anaconda, das ist irgendwie so ein Paket, womit man ganz viel

00:38:45.420 --> 00:38:47.340
tolle Datensachen machen kann, wo es

00:38:47.340 --> 00:38:49.300
vorinstalliert ist. Also ich persönlich hatte da

00:38:49.300 --> 00:38:51.180
nicht so die besten Erfahrungen mit, das war einmal sehr

00:38:51.180 --> 00:38:53.320
verwurschtelt mit den Paketen, dann lief

00:38:53.320 --> 00:38:54.940
immer was nicht, wenn es irgendwie ein Update gab von der

00:38:54.940 --> 00:38:56.580
neuesten Python-Version. Die haben auch einen eigenen

00:38:56.580 --> 00:38:59.000
Paketmanager, Anaconda irgendwie und deswegen

00:38:59.000 --> 00:39:01.380
würde ich das für Anfänger jetzt nicht unbedingt sofort empfehlen,

00:39:01.380 --> 00:39:03.320
obwohl viele das machen, aber das könnt ihr

00:39:03.320 --> 00:39:05.160
ja selber schauen. Ja, Anaconda ist ein bisschen

00:39:05.160 --> 00:39:07.080
verwirrend, weil also eben

00:39:07.080 --> 00:39:08.920
es ist eben kein Paketmanager und auch

00:39:08.920 --> 00:39:11.160
nicht... Also Anaconda ist eine Distribution

00:39:11.160 --> 00:39:13.020
sozusagen von Paketen,

00:39:13.020 --> 00:39:14.700
aber

00:39:14.700 --> 00:39:15.380
...

00:39:15.380 --> 00:39:17.200
Anaconda ist der Paketmanager und es gibt

00:39:17.200 --> 00:39:19.440
auch noch ganz viele andere Pakete,

00:39:19.440 --> 00:39:20.900
die jetzt nicht in der Anaconda-Distribution

00:39:20.900 --> 00:39:22.600
drin sind. Und

00:39:22.600 --> 00:39:25.100
das ist so ein bisschen... Eigentlich ist das

00:39:25.100 --> 00:39:26.740
alles ein bisschen furchtbar. Man muss sagen, dass

00:39:26.740 --> 00:39:29.200
schön wäre ja, sozusagen in einer idealen

00:39:29.200 --> 00:39:30.520
Welt hätte man das ja gerne, dass man

00:39:30.520 --> 00:39:32.760
sozusagen einen Paketmanager für alles verwendet.

00:39:32.760 --> 00:39:35.020
Also es gibt auch so ein bisschen die

00:39:35.020 --> 00:39:37.280
Utopie, wird so ein bisschen

00:39:37.280 --> 00:39:38.180
gelebt bei

00:39:38.180 --> 00:39:40.080
NixOS.

00:39:40.080 --> 00:39:42.880
Versuchen Leute das tatsächlich noch umzusetzen

00:39:42.880 --> 00:39:45.340
oder eigentlich waren auch die Linux-Distributionen mal so

00:39:45.340 --> 00:39:47.080
quasi gedacht, dass man halt

00:39:47.080 --> 00:39:49.340
hat einen Paketmanager, mit dem installiert man halt

00:39:49.340 --> 00:39:51.400
irgendwie alles, was man irgendwie haben möchte.

00:39:51.400 --> 00:39:52.840
Und

00:39:52.840 --> 00:39:55.520
das geht ja auch jetzt noch, wenn man jetzt

00:39:55.520 --> 00:39:57.280
einen Debian hat beispielsweise, dann kann man auch

00:39:57.280 --> 00:39:59.340
einen NumPy oder so, was ja

00:39:59.340 --> 00:40:01.700
quasi ein Modul ist

00:40:01.700 --> 00:40:03.220
für Scientific Computing, ein Modul für

00:40:03.220 --> 00:40:05.500
Python, kann man durchaus per

00:40:05.500 --> 00:40:07.440
Debian-Paket installieren, also über die Distribution.

00:40:07.440 --> 00:40:09.680
Es ist halt nur so, dass man das nicht tun

00:40:09.680 --> 00:40:11.640
sollte, weil dann bekommt man eine Version, die nicht optimiert ist,

00:40:11.640 --> 00:40:13.560
wo der Maintainer... Also ich meine, vielleicht

00:40:13.560 --> 00:40:14.980
ist es auch gut, ich weiß keine Ahnung,

00:40:15.340 --> 00:40:17.440
aber die Wahrscheinlichkeit ist hoch,

00:40:17.440 --> 00:40:19.140
dass es eben dann nicht schnell ist.

00:40:19.140 --> 00:40:21.300
Weil es ist halt nicht gegen MKL

00:40:21.300 --> 00:40:23.540
diese Mathe-Bibliothek von Intel

00:40:23.540 --> 00:40:25.640
gelingt beim Kompilieren.

00:40:25.640 --> 00:40:27.520
Also es ist halt tricky, das zu kompilieren,

00:40:27.520 --> 00:40:28.820
da ist viel Core-Transworks dabei.

00:40:28.820 --> 00:40:31.060
Das ist alles nicht so einfach und

00:40:31.060 --> 00:40:33.640
überfordert möglicherweise

00:40:33.640 --> 00:40:34.900
halt den Debian-Maintainer auch so ein bisschen.

00:40:34.900 --> 00:40:37.440
Also du würdest auch immer

00:40:37.440 --> 00:40:39.080
alle Pakete über PIP installieren?

00:40:39.080 --> 00:40:41.260
Naja, nee, ich würde sagen, es kommt drauf an.

00:40:41.260 --> 00:40:42.900
Leider haben wir nicht...

00:40:42.900 --> 00:40:45.320
Am schönsten wäre es, wir hätten einen Paketmanager für alles,

00:40:45.340 --> 00:40:46.820
also zum Beispiel PIP oder deinen

00:40:46.820 --> 00:40:47.840
Distributionsmanager.

00:40:47.840 --> 00:40:51.000
Oder weiß nicht, was es dabei

00:40:51.000 --> 00:40:53.280
bei YAMM für

00:40:53.280 --> 00:40:54.800
Red Hat gibt oder was da noch war.

00:40:54.800 --> 00:40:57.200
DNF ist mittlerweile, glaube ich, auch bei Red Hat, also zumindest bei Fedora.

00:40:57.200 --> 00:40:57.680
Ja.

00:40:57.680 --> 00:41:01.260
Ich bin da auch gar nicht mehr so am Laufen, aber

00:41:01.260 --> 00:41:02.520
genau.

00:41:02.520 --> 00:41:05.340
Wenn man einen Paketmanager hätte, mit dem man alles installiert

00:41:05.340 --> 00:41:07.300
und dann sich relativ sicher

00:41:07.300 --> 00:41:08.860
sein könnte, dass das halt irgendwie funktioniert, das wäre

00:41:08.860 --> 00:41:10.960
schön. Aber

00:41:10.960 --> 00:41:13.340
es hat sich jetzt aber eher so entwickelt, dass

00:41:13.340 --> 00:41:15.240
jede Programmiersprache so ein bisschen,

00:41:15.340 --> 00:41:17.400
ihren eigenen Paketmanager mitbringt.

00:41:17.400 --> 00:41:19.780
Also bei Python ist es halt

00:41:19.780 --> 00:41:21.180
erst mal PIP.

00:41:21.180 --> 00:41:23.080
So wie bei Ruby ist das dann halt...

00:41:23.080 --> 00:41:24.780
sind das diese Ruby-Gems.

00:41:24.780 --> 00:41:27.300
Bei Perl ist es Cpan bzw.

00:41:27.300 --> 00:41:28.660
ich weiß gar nicht, was jetzt das

00:41:28.660 --> 00:41:30.900
Ding ist, mit dem man die Dinger installiert.

00:41:30.900 --> 00:41:32.740
Dann bei, weiß ich nicht,

00:41:32.740 --> 00:41:34.860
JavaScript ist es halt NPM oder YAM

00:41:34.860 --> 00:41:36.860
oder was auch immer man da gerade verwendet.

00:41:36.860 --> 00:41:39.300
Und

00:41:39.300 --> 00:41:41.980
das ist dann natürlich nicht mehr so toll, weil das

00:41:41.980 --> 00:41:45.320
Problem ist, dass wenn man die jetzt benutzt, die Sachen

00:41:45.340 --> 00:41:47.940
wenn man die jetzt quasi einfach so

00:41:47.940 --> 00:41:50.480
ins Notfallsystem installiert, dann überschreiben

00:41:50.480 --> 00:41:52.740
die natürlich Sachen, die die Disponition da reingeschreibt hat.

00:41:52.740 --> 00:41:54.020
Die überschreiben sich doch auch gegenseitig in verschiedenen...

00:41:54.020 --> 00:41:56.380
Die überschreiben sich gegenseitig. Alles nicht so schön.

00:41:56.380 --> 00:41:58.840
Da hat niemand drauf aufgepasst, dass die Sachen auch alle miteinander

00:41:58.840 --> 00:42:02.600
klarkommen. Das heißt, es können die komischsten Dinge passieren.

00:42:02.600 --> 00:42:04.900
Das ist halt nicht so toll.

00:42:04.900 --> 00:42:06.900
Was macht man denn da? Dafür gibt's ja eine Lösung.

00:42:06.900 --> 00:42:12.480
Ja, dafür versucht man das dann irgendwie zu isolieren und installiert halt Dinge nur in Environments.

00:42:12.480 --> 00:42:14.480
Also in virtuellen Entwicklungen.

00:42:14.480 --> 00:42:16.480
In virtuellen Umgebungen, genau.

00:42:16.480 --> 00:42:20.900
Oder für seinen einen User. Also zum Beispiel "pip install paketname --user"

00:42:20.900 --> 00:42:21.400
Ja.

00:42:21.400 --> 00:42:23.400
Würde halt das für den aktuellen Nutzer nur installieren.

00:42:23.400 --> 00:42:25.400
Genau, das kann man auch machen.

00:42:25.400 --> 00:42:32.780
Und das sind halt so bisschen krütige Lösungen für dieses Problem.

00:42:32.780 --> 00:42:35.680
Aber leider ist es sogar noch schlimmer.

00:42:35.680 --> 00:42:38.600
Es ist jetzt nicht nur so, dass jeder Programmiersparer einen eigenen

00:42:38.600 --> 00:42:43.620
Paketmanager hat, sondern es sieht so ein bisschen, also jedenfalls bei Python

00:42:43.620 --> 00:42:48.460
ist es leider so, dass auch jede Community hat sozusagen ihren eigenen Paketmanager nochmal.

00:42:48.460 --> 00:42:54.460
Die ganze Web-Community verwendet eigentlich überwiegend pip, während die ganze Data-Science-Community

00:42:54.460 --> 00:42:58.460
überwiegend conda verwendet. Und wenn man sagen muss, conda ist ein bisschen mächtiger als pip.

00:42:58.460 --> 00:43:02.460
Man kann damit nicht nur Python-Pakete installieren, sondern halt auch diverse andere Binär-Pakete.

00:43:02.460 --> 00:43:06.460
Und manchmal muss man das halt dummerweise auch, weil viele der Sachen, die man da verwendet, sind halt

00:43:06.460 --> 00:43:09.460
Fortran-Bibliotheken oder irgendwelche C-Bibliotheken oder C++.

00:43:09.460 --> 00:43:12.620
Warum verwendet man denn Fortran oder C- oder C++-Bibliotheken in Python?

00:43:12.620 --> 00:43:20.620
Ja, genau. Das ist halt auch, weil wenn man jetzt zum Beispiel Matrizen miteinander multiplizieren will oder so,

00:43:20.620 --> 00:43:24.620
dann könnte man das natürlich auch in Python machen, indem man einfach For-Loops ineinander schachtelt.

00:43:24.620 --> 00:43:29.620
Also man speichert die Dinger einfach quasi als zweiendimensionale Listen oder so.

00:43:29.620 --> 00:43:36.620
Man hat einfach eine Liste von Listen und dann quasi eine Liste von Spalten oder Zeilen.

00:43:36.620 --> 00:43:38.620
Moment, NumPy, glaube ich. Geht das so?

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

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

00:43:38.620 --> 00:43:39.620
Ja, ja, genau. Also man könnte es direkt in Python machen. Dann macht man halt irgendwie so eine Liste von Spalten oder Zeilen.

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

00:43:48.620 --> 00:43:53.620
Das kann man machen. Das ist halt dann sehr, sehr langsam.

00:43:53.620 --> 00:44:03.620
Wenn man jetzt so eine Bibliothek benutzt wie NumPy oder so, die haben dann halt einen speziellen Array-Type sozusagen.

00:44:03.620 --> 00:44:06.620
Und wenn man da jetzt sagt, multiplizieren wir mal A und B,

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

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

00:44:06.620 --> 00:44:07.620
dann nutzt man dann halt einen speziellen Array-Type sozusagen. Und wenn man da jetzt sagt, multiplizieren wir mal A und B,

00:44:09.620 --> 00:44:15.820
Und Nampai unten drunter halt quasi, weiß ich jetzt gar nicht, was man da möchte.

00:44:15.820 --> 00:44:22.180
Ich würde mir jetzt gerade so auszumalen, wie das dann so aussieht in dem Schaubild, um mir das irgendwie so ein bisschen vorzustellen, warum das jetzt schneller geht.

00:44:22.180 --> 00:44:25.160
Also die benutzen drunter einen neuen Motor.

00:44:25.160 --> 00:44:27.260
Benutzen drunter optimierte Fortran-Bibliotheken.

00:44:27.260 --> 00:44:30.260
Oder ist es, ich weiß gar nicht mal, ob es Fortran ist unbedingt.

00:44:30.260 --> 00:44:34.600
Also es ist halt irgendwie, die haben halt damals angefangen mit Blas Lafac Atlas.

00:44:34.600 --> 00:44:36.300
Das sind so die Dinger, die da unten drunter liegen.

00:44:37.080 --> 00:44:43.540
Und es gibt, glaube ich, irgendwie so eine definierte Schnittstelle für solche, für diese ganzen Operationen.

00:44:43.540 --> 00:44:46.320
Und dann sind das irgendwie Implementationen davon.

00:44:46.320 --> 00:44:48.020
Und ja.

00:44:48.020 --> 00:44:51.020
Nennen wir es Magic.

00:44:51.020 --> 00:44:52.140
Genau, Magie.

00:44:52.140 --> 00:44:57.780
Also Fortran ist halt irgendwie, als Sprache ist es immer noch deswegen so wichtig, weil da Sachen sich quasi mehr oder weniger automatisch vektorisieren lassen.

00:44:57.780 --> 00:45:05.760
Das bedeutet, dass man nicht loopt über Sachen, sondern dass der Prozessor das quasi übernimmt.

00:45:06.800 --> 00:45:09.420
Also das ist, also wenn man das einfach an C kommt, dann sollte ich auch eine Loop hinschreiben.

00:45:09.420 --> 00:45:10.600
Wäre schon viel schneller als ein Python.

00:45:10.600 --> 00:45:11.980
Wahrscheinlich so tausendmal schneller oder so.

00:45:11.980 --> 00:45:19.720
Aber selbst das wäre deutlich langsamer als das, was quasi die Bibliotheken, die unter einem Namenpeil liegen, halt machen.

00:45:19.720 --> 00:45:20.440
Nee, stimmt.

00:45:20.440 --> 00:45:21.060
Genau.

00:45:21.060 --> 00:45:24.760
Hat so ein bisschen den Nachteil, dass man halt den Code anders strukturieren muss.

00:45:24.760 --> 00:45:31.920
Man kann eben dann keine Vorschleife mehr verwenden, sondern man macht eher solche Sachen, wie man auf den Objekten, die man erzeugt hat,

00:45:31.920 --> 00:45:36.760
wie zum Beispiel irgendwelche Arrays oder so, ruft man dann halt irgendwie eine Funktion auf und übergibt denen ein Callback oder so.

00:45:36.800 --> 00:45:38.800
Weil Vorschleifen gehen halt nicht mehr.

00:45:38.800 --> 00:45:42.800
Das ist ein bisschen komisch, aber ist halt dafür schnell.

00:45:42.800 --> 00:45:44.800
Wie ist da so ein Trade-Off?

00:45:44.800 --> 00:45:48.800
Kann man sich überlegen, ob man sich das angewöhnt hat, dass man das gerne macht oder ob man sagt, hey, wir nehmen jetzt das ein bisschen in Kauf.

00:45:48.800 --> 00:45:50.800
Python ist ja immer als langsam verschrien.

00:45:50.800 --> 00:45:54.800
Aber wenn wir die auch schnell bekommen, ja okay, dann machen wir vielleicht mal einen kleinen Umweg.

00:45:54.800 --> 00:45:55.800
Genau, genau.

00:45:55.800 --> 00:45:57.800
Ja, kommen wir vielleicht noch zu, wenn es um die Mythen geht.

00:45:57.800 --> 00:46:00.800
Aber man kann damit auch sehr schnell Dinge tun.

00:46:00.800 --> 00:46:05.800
Und dafür muss es halt auch Bibliotheken basieren, die das halt auch schnell machen können.

00:46:05.800 --> 00:46:09.800
Und für Scientific Computing und Zeugs ist es halt vortragen oft.

00:46:09.800 --> 00:46:11.800
Ja, genau.

00:46:11.800 --> 00:46:14.800
Ja, vielleicht nochmal genau zu diesen ganzen Bibliotheken, die man machen kann.

00:46:14.800 --> 00:46:18.800
Du hast gesagt, glaube ich, Data Science kann man ganz viel machen und Web kann man ganz viel machen.

00:46:18.800 --> 00:46:22.800
Und für diesen Glue, also den Klebstoff zwischen einzelnen Modulen, kann man ganz viel machen.

00:46:22.800 --> 00:46:23.800
Und so zum Skripten.

00:46:23.800 --> 00:46:25.800
Fällt dir noch irgendwas ein?

00:46:25.800 --> 00:46:26.800
Oh, ja, ja, ja.

00:46:26.800 --> 00:46:27.800
Was ich ein bisschen vernachlässige.

00:46:27.800 --> 00:46:30.800
Genau, auch ein Bereich, der momentan sehr interessant wird.

00:46:30.800 --> 00:46:34.800
So Home Automation Zeugs, Smart Home.

00:46:34.800 --> 00:46:35.800
Raspberry Pi, der macht ja ganz...

00:46:35.800 --> 00:46:36.800
Ja, genau.

00:46:36.800 --> 00:46:37.800
Raspberry Pi wird da oft verwendet.

00:46:37.800 --> 00:46:42.800
Und überhaupt Raspberry Pi und Python haben viele schöne Anwendungen.

00:46:42.800 --> 00:46:44.800
Da kann man viel drauf machen.

00:46:44.800 --> 00:46:47.800
Home Automation, du hast hier, glaube ich, ganz viele schöne Sachen mit.

00:46:47.800 --> 00:46:52.800
Ja, ich habe auch einen Raspberry Pi irgendwo im Schrank stehen, der zum Beispiel Temperaturen ausliest.

00:46:52.800 --> 00:46:55.800
Ich habe so ein DVB-T-Modul da dran gesteckt.

00:46:55.800 --> 00:46:57.800
Die gibt es jetzt irgendwie günstig, weil es keinen DVB-T-Modul gibt.

00:46:57.800 --> 00:46:59.800
Ich wollte gerade sagen, also das ist doch gerade abgeschaltet worden.

00:46:59.800 --> 00:47:00.800
Richtig.

00:47:00.800 --> 00:47:02.800
Jetzt kommen wir in die Dongle, kriegt man relativ billig.

00:47:02.800 --> 00:47:03.800
Und da ist so eine Sache.

00:47:03.800 --> 00:47:08.800
Und da ist so eine Antenne dran und dann habe ich hier irgendwie so Sensoren und die funken halt auf den Frequenzen.

00:47:08.800 --> 00:47:11.800
Ihre Werte halt so alle paar Sekunden oder so.

00:47:11.800 --> 00:47:17.800
Und dann muss man die eigentlich dann nur einsammeln und dann an ein Software, das nennt sich Home Assistant, schicken.

00:47:17.800 --> 00:47:18.800
Also das ist ein bisschen komplizierter.

00:47:18.800 --> 00:47:20.800
Ja, da macht man auch noch eine eigene Folge für sich.

00:47:20.800 --> 00:47:21.800
Genau.

00:47:21.800 --> 00:47:22.800
Aber solche Sachen.

00:47:22.800 --> 00:47:23.800
Also wenn man zum Beispiel...

00:47:23.800 --> 00:47:27.800
Also ich sehe jetzt aber zum Beispiel keine Schläuche in den Pflanzen, die du hier in deinem schönen Wintergarten stehen hast.

00:47:27.800 --> 00:47:29.800
Das heißt, das musst du noch selber gießen.

00:47:29.800 --> 00:47:30.800
Genau.

00:47:30.800 --> 00:47:31.800
Ja, furchtbar.

00:47:31.800 --> 00:47:32.800
Da musst du unbedingt automatisiert werden.

00:47:32.800 --> 00:47:35.800
Ich weiß noch nicht, wie ich den Wassertransport automatisieren soll.

00:47:35.800 --> 00:47:36.800
Das ist ein bisschen gefährlich.

00:47:36.800 --> 00:47:38.800
Eine Pumpe irgendwie und ein Eimer einfach.

00:47:38.800 --> 00:47:39.800
Ohne Haftpflichtversicherung.

00:47:39.800 --> 00:47:43.800
Ja, wäre eine Idee tatsächlich vielleicht.

00:47:43.800 --> 00:47:46.800
Ja, genau.

00:47:46.800 --> 00:47:50.800
Ja, aber in dem Bereich ist Python halt auch, glaube ich, sehr, sehr stark unterwegs.

00:47:50.800 --> 00:47:52.800
Und da gerade, wenn man jetzt...

00:47:52.800 --> 00:47:54.800
Also einmal auf der Serverseite sozusagen.

00:47:54.800 --> 00:48:01.800
Also das Ding, was diese ganzen smarten, mehr oder weniger smarten Geräte halt sozusagen managt.

00:48:01.800 --> 00:48:04.800
Und mit denen da irgendwas macht, irgendwelche Sensordaten ausliest.

00:48:04.800 --> 00:48:06.800
Die Seite ist Python.

00:48:06.800 --> 00:48:08.800
Aber halt auch die Sensoren selber.

00:48:08.800 --> 00:48:09.800
Also man kann zum Beispiel...

00:48:09.800 --> 00:48:12.800
Es gibt da so kleine Boards.

00:48:12.800 --> 00:48:13.800
Kosten ein paar Dollar.

00:48:13.800 --> 00:48:18.800
Und da ist ein Chip drauf mit ein wenig...

00:48:18.800 --> 00:48:20.800
Ist nicht so schnell und hat auch wenig Speicher.

00:48:20.800 --> 00:48:23.800
Aber da läuft Micro-Python zum Beispiel drauf, sodass man da halt...

00:48:23.800 --> 00:48:24.800
Nächste Folge.

00:48:24.800 --> 00:48:25.800
Ja, genau.

00:48:25.800 --> 00:48:29.800
Das heißt, man kann auch da Python drauflaufen lassen.

00:48:29.800 --> 00:48:30.800
Und dann irgendwie Sensordaten.

00:48:30.800 --> 00:48:31.800
Damit schon irgendwas machen.

00:48:31.800 --> 00:48:34.800
Da muss man erst mal wieder aufpassen, dass wir die Module so nehmen, dass sie möglichst klein werden.

00:48:34.800 --> 00:48:35.800
Genau.

00:48:35.800 --> 00:48:37.800
Da muss man wieder ein bisschen aufpassen und so.

00:48:37.800 --> 00:48:42.800
Aber ja, also in dem Bereich ist Python halt auch sehr, sehr stark vertreten.

00:48:42.800 --> 00:48:46.800
Ja, ich glaube, was noch dazukommt vielleicht ist Rapid Prototyping.

00:48:46.800 --> 00:48:48.800
Jetzt nochmal als Buzzword reingeschmissen.

00:48:48.800 --> 00:48:51.800
Man kann relativ schnell irgendwelche Prototypen bauen von Dingen, die man benutzt.

00:48:51.800 --> 00:48:55.800
Sei es jetzt im Web oder bei Daten, die dann auch funktionieren, die kurz sind.

00:48:55.800 --> 00:48:57.800
Wenn man jetzt zum Beispiel die Sprachvergleiche...

00:48:57.800 --> 00:48:58.800
Ist ja auch sehr einfach.

00:48:58.800 --> 00:48:59.800
Deswegen eignet sich das besonders gut.

00:48:59.800 --> 00:49:04.800
Ist vielleicht am nächsten am Pseudocode dran, so von dem, was ich so gesehen habe.

00:49:04.800 --> 00:49:10.800
Das heißt, man kann relativ einfach die Syntax formulieren und hat direkt ein glaubfähiges Programm,

00:49:10.800 --> 00:49:13.800
was wenigstens so grob das tut, was es sollte später.

00:49:13.800 --> 00:49:14.800
Ja.

00:49:14.800 --> 00:49:20.800
Dazu sozusagen ist noch so einer große Vorteil der Sprache, wo man jetzt von außen draufguckt.

00:49:20.800 --> 00:49:22.800
Für den Anfängern oder so.

00:49:22.800 --> 00:49:26.800
Ja, vielleicht wäre es ganz interessant, das mal so ein bisschen zu differenzieren gegenüber den anderen Sprachen,

00:49:26.800 --> 00:49:27.800
die es halt in den ganzen Bereichen auch gibt.

00:49:27.800 --> 00:49:28.800
Ja.

00:49:28.800 --> 00:49:30.800
Wo man auch diese ganzen Dinge tun kann.

00:49:30.800 --> 00:49:37.800
Also Python ist halt, würde ich sagen, gehört zur Familie der Skript-Sprachen irgendwie.

00:49:37.800 --> 00:49:42.800
Also man könnte sagen, es ist sowas ähnliches wie Ruby oder wie Perl oder auch ein bisschen wie JavaScript.

00:49:42.800 --> 00:49:45.800
Aber unterscheidet sich halt...

00:49:45.800 --> 00:49:47.800
Oder PHP unterscheidet sich von denen aber.

00:49:47.800 --> 00:49:57.800
Also wie zum Beispiel JavaScript und PHP, die sind halt dynamisch getypt sozusagen und schwach getypt.

00:49:57.800 --> 00:50:07.800
Das heißt, Dinge können ihren Typ ändern oder man weiß nicht, was sie sind sozusagen von Anfang an.

00:50:07.800 --> 00:50:08.800
Ja, also Python auch so.

00:50:08.800 --> 00:50:09.800
Ist in Python auch so.

00:50:09.800 --> 00:50:10.800
Ja.

00:50:10.800 --> 00:50:14.800
Aber in Python ist halt streng getypt auch.

00:50:14.800 --> 00:50:16.800
Das heißt, es ist dynamisch und streng.

00:50:16.800 --> 00:50:21.800
Das heißt, wenn ich jetzt sage, irgendwie eine Zahl plus irgendwie ein String oder so,

00:50:21.800 --> 00:50:25.800
dann kriege ich bei Python halt einen Type Error, also...

00:50:25.800 --> 00:50:26.800
Einen Typenfehler.

00:50:26.800 --> 00:50:27.800
Einen Typenfehler.

00:50:27.800 --> 00:50:29.800
Ja, also ich versuche eine Zahl mit einem Wort zu verrechnen.

00:50:29.800 --> 00:50:30.800
Genau.

00:50:30.800 --> 00:50:35.800
Da haut mir Python halt auf die Finger, während in PHP oder in JavaScript passiert dann halt irgendwas.

00:50:35.800 --> 00:50:36.800
Und was passiert denn da?

00:50:36.800 --> 00:50:37.800
Ist das Magie?

00:50:37.800 --> 00:50:39.800
Oder ist das keine dunkle Magie wahrscheinlich?

00:50:39.800 --> 00:50:40.800
Es ist eher dunkel.

00:50:40.800 --> 00:50:42.800
Also man weiß nicht so genau, was dann passiert.

00:50:42.800 --> 00:50:44.800
Es kommen die komischsten Sachen.

00:50:44.800 --> 00:50:49.800
Aber es gibt einen schönen Vortrag für JavaScript.

00:50:49.800 --> 00:50:50.800
Das ist mal jemand...

00:50:50.800 --> 00:50:54.800
Es ist ein bisschen veraltet, aber hat das mal jemand aufgeschrieben.

00:50:54.800 --> 00:50:55.800
Ich glaube, wenn man danach sucht.

00:50:55.800 --> 00:51:00.800
So JavaScript Talk und dann Watt, W-A-T, dann findet man das.

00:51:00.800 --> 00:51:05.800
Und dann, wo er dann so eben solche Dinge macht wie irgendeine Zahl plus leer Stringen.

00:51:05.800 --> 00:51:07.800
Und dann kommen halt die seltsamsten Dinge dabei raus.

00:51:07.800 --> 00:51:09.800
Oder selber hüpft und blinkt und...

00:51:09.800 --> 00:51:12.800
Ja, am Schluss kommen irgendwelche Zeichenkanten dabei raus und Batman erscheint.

00:51:12.800 --> 00:51:13.800
Also es ist halt wirklich...

00:51:13.800 --> 00:51:14.800
Man muss aufpassen, dass man da tut.

00:51:14.800 --> 00:51:16.800
Ansonsten passieren ganz, ganz furchtbare Dinge.

00:51:16.800 --> 00:51:18.800
Klingt so, als könnte man das gut ausnutzen.

00:51:18.800 --> 00:51:19.800
Ja.

00:51:19.800 --> 00:51:24.800
Und es passieren halt auch regelmäßig wirklich, wirklich schlimme Sachen.

00:51:24.800 --> 00:51:26.800
Die Welt geht unter.

00:51:26.800 --> 00:51:27.800
Ja, ja.

00:51:27.800 --> 00:51:28.800
So ungefähr.

00:51:28.800 --> 00:51:30.800
Und das kann bei einem Python halt nicht so leicht passieren.

00:51:30.800 --> 00:51:31.800
Das ist schon mal ganz schön.

00:51:31.800 --> 00:51:34.800
Also insofern ist es halt in der Welt...

00:51:34.800 --> 00:51:36.800
Es ist halt ein schöner...

00:51:36.800 --> 00:51:40.800
Also ich finde, was man über Python sagen kann, ist, es macht halt die richtigen Tradeoffs.

00:51:40.800 --> 00:51:41.800
Also es ist halt immer...

00:51:41.800 --> 00:51:42.800
Es ist halt so eine Sache.

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

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

00:52:26.930 --> 00:52:31.090
Ja, aber das Schöne ist halt, das ist halt optional. Man kann das da ranschreiben.

00:52:31.090 --> 00:52:31.870
Also klar.

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

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

00:53:01.770 --> 00:53:09.630
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.

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

00:53:23.930 --> 00:53:31.030
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.

00:53:31.770 --> 00:53:37.110
Aber man braucht dann halt eine komplizierte IDE, die irgendwie Dinge tut und dann auch nicht mehr so schnell sein kann.

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

00:53:55.770 --> 00:54:01.770
Ja gut, aber das geht auch. In Python hat man das jetzt halt so nicht, das ist alles dynamisch.

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

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

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

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

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

00:55:58.170 --> 00:56:01.710
Ja, das musst du unbedingt auch in die Show noch packen.

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

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

00:56:31.770 --> 00:56:38.830
komplizierte, komplizierte Dinge ausdenken, mit denen ich halt irgendwie da jetzt Architektur-Dinge, mit denen ich da mit diesem Problem fertig werde, weil ich hab das Problem gar nicht.

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

00:56:52.590 --> 00:56:56.570
So in Python hat man einen Großteil dieser Probleme, hat man einfach nicht.

00:56:56.570 --> 00:56:57.490
So loslegen, machen.

00:56:57.490 --> 00:56:58.150
Ja.

00:56:58.150 --> 00:56:58.690
Ja.

00:56:58.690 --> 00:57:01.150
Und das ist halt schon sehr schön, das ist ein großer Vorteil.

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

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

00:57:24.010 --> 00:57:30.890
Ähm, ja, das, das ist, äh, das wäre so der Unterschied statisch getypt, äh, dynamisch, äh, dynamisch getypt.

00:57:30.890 --> 00:57:31.750
Genau.

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

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

00:57:52.430 --> 00:57:56.630
Und da muss man immer so einen Zeiger durch den Speicher schicken, der genau sagt, wo man gerade ist.

00:57:56.630 --> 00:58:00.630
Ja, also, genau, also, äh.

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

00:58:08.290 --> 00:58:15.450
Äh, oder, ja, wenn man Dinge freigibt, die man, äh, die, die eigentlich man noch braucht, und es passieren schreckliche Dinge.

00:58:15.450 --> 00:58:17.970
Also, das ist, äh, kann man...

00:58:17.970 --> 00:58:18.610
Und wie löst man das in Python?

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

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

00:58:58.210 --> 00:58:59.350
Wie Python?

00:58:59.350 --> 00:59:01.750
Nee, ja, also, Python hat auch einen Garbage-Collector.

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

00:59:11.050 --> 00:59:14.030
Das heißt, es zählt, wie oft ist irgendwas irgendwo da, und wenn es nicht mehr da ist, dann zahlt es weg.

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

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

00:59:49.670 --> 00:59:50.830
Okay.

00:59:50.830 --> 00:59:57.250
Der große Nachteil ist, äh, ja, man kann dann nicht mehr Parallel-Dinge machen.

00:59:57.250 --> 00:59:58.050
Oh Gott, oh Gott, oh Gott.

00:59:58.050 --> 01:00:01.590
Also auf unterschiedlichen Prozessoren. Das geht im Grunde nicht mehr.

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

01:00:18.750 --> 01:00:20.990
Wenn man das tut, wird alles ungefähr 40 Mal so langsam.

01:00:20.990 --> 01:00:23.710
Und das geht alles einfach nicht mehr.

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

01:00:31.770 --> 01:00:36.710
Aber, äh, das heißt, du brauchst 20 Kerne, damit du dann den einen Kern, die Performance von einem Kern hinkriegst, genau.

01:00:36.710 --> 01:00:38.810
Äh, das ist natürlich irgendwie nicht so richtig effizient.

01:00:38.810 --> 01:00:41.990
Also, äh, das ist natürlich ein großer Nachteil.

01:00:41.990 --> 01:00:45.390
Und dafür gibt's halt bei, bei Python auch den, den, den Global Interpreter-Lock.

01:00:45.390 --> 01:00:47.170
Den, den bitte was?

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

01:01:01.770 --> 01:01:04.590
Und nicht, äh, ein, ein Python-Prozess auf mehreren CPUs laufen kann.

01:01:04.590 --> 01:01:05.890
Ja.

01:01:05.890 --> 01:01:09.730
Ähm, das ist halt so.

01:01:09.730 --> 01:01:11.390
Also, das ist auch der Grund, warum Java das nicht macht.

01:01:11.390 --> 01:01:15.330
Java, äh, macht, äh, einen Garbage-Collector und hat dann dieses Problem nicht.

01:01:15.330 --> 01:01:17.450
Ja, das kann dann halt auf mehreren Prozessoren laufen, problemlos.

01:01:17.450 --> 01:01:19.790
Oder, naja, problemlos, aber geht.

01:01:19.790 --> 01:01:24.990
Und, äh, sozusagen, muss dann halt ab und zu mal aufräumen.

01:01:24.990 --> 01:01:26.390
Dafür ist eben dieser Garbage-Collector.

01:01:26.390 --> 01:01:28.230
Das heißt, auf einmal gibt's eine Pause.

01:01:28.230 --> 01:01:29.570
Nee, der Müllteil ist voll.

01:01:29.570 --> 01:01:31.530
Jetzt muss der Müll aus, muss erstmal alles einsammeln.

01:01:31.770 --> 01:01:32.170
Und wegfahren.

01:01:32.170 --> 01:01:32.530
Genau.

01:01:32.530 --> 01:01:34.930
Das, das Problem ist, man weiß halt nie genau, wann der zuschlägt.

01:01:34.930 --> 01:01:37.890
Und dann, das bedeutet halt, dass man, wenn man einen Server laufen hat, dann kann das

01:01:37.890 --> 01:01:40.770
halt sein, dass man irgendwie plötzlich, es sind halt alle Requests super schnell und

01:01:40.770 --> 01:01:41.710
dann plötzlich einer dauert halt lang.

01:01:41.710 --> 01:01:44.230
Also jetzt, um da bei dem Müllauto-Beispiel zu bleiben, kann man nicht einfach messen,

01:01:44.230 --> 01:01:48.870
also wie voll der Müllcontainer ist und, äh, dann irgendwie den Müllwagen so gut fahren

01:01:48.870 --> 01:01:51.870
lassen, dass der ein Routenmanagement macht und da richtig vorbeifährt und die Sachen

01:01:51.870 --> 01:01:53.550
rechtzeitig lädt, bevor die vollgelaufen sind?

01:01:53.550 --> 01:01:57.170
Ja, aber das Problem ist halt, du musst irgendwann halt alle...

01:01:57.170 --> 01:01:59.890
Weiß nicht, wie viele Leute die Müll essen und wie viel Müll die wegschmeißen immer,

01:01:59.890 --> 01:02:00.130
oder?

01:02:00.770 --> 01:02:03.670
Ja, ja, ja, also da wird auch eine ganze Menge gemacht und es funktioniert auch alles

01:02:03.670 --> 01:02:06.830
irgendwie so ganz okay, aber das Problem wirst du im Grunde nicht los.

01:02:06.830 --> 01:02:10.550
Du hast immer das Problem, dass wenn, wenn der Müll weggebracht werden muss, musst du

01:02:10.550 --> 01:02:13.870
allen sagen, so jetzt mal stopp, jetzt muss erstmal der Müll weggebracht werden.

01:02:13.870 --> 01:02:15.230
Aber die schmeißen alles in dieselbe Mülltonne.

01:02:15.230 --> 01:02:21.030
Ja, und, äh, dann, ja, selbst wenn das sehr schnell ist, kann es halt sein, dass es, weiß

01:02:21.030 --> 01:02:22.590
ich nicht, 200 Millisekunden dauert oder sowas.

01:02:22.590 --> 01:02:24.130
Könnte man nicht einfach eine kleinere Mülltonne machen?

01:02:24.130 --> 01:02:26.450
Also für jeden so eine kleinere Mülltonne, als wenn man so eine große hat?

01:02:26.450 --> 01:02:28.950
Ja, ich weiß es nicht.

01:02:28.950 --> 01:02:29.770
Aber dieses Problem ist...

01:02:29.770 --> 01:02:33.830
Aber dieses Problem ist nach wie vor da, also nach wie vor kämpfen da Leute mit.

01:02:33.830 --> 01:02:35.470
Sagen wir mal, das ist halt einer der Trade-offs.

01:02:35.470 --> 01:02:39.270
Wenn du halt einen Garbage Collector hast, dann hast du halt, dann kannst du halt irgendwie

01:02:39.270 --> 01:02:41.790
Sachen auf mehrere Prozessoren verteilen, aber du hast halt den Nachteil, dass deine

01:02:41.790 --> 01:02:43.790
Latenz so ein bisschen unvorhersagbar wird.

01:02:43.790 --> 01:02:46.870
Ähm, ja, das ist halt blöd.

01:02:46.870 --> 01:02:53.190
Und, ähm, ja, das, äh, das sind halt, man kann sich halt überlegen, was man irgendwie

01:02:53.190 --> 01:02:54.330
lieber mag, äh, sozusagen.

01:02:54.330 --> 01:02:58.770
Und auch da, äh, finde ich, dass Python da eine ganz gute, äh, ganz gute, äh,

01:02:58.770 --> 01:03:01.170
gute Wahl getroffen hat mit dem Reference Counting.

01:03:01.170 --> 01:03:03.470
Und auch da gibt es halt den Garbage Collector, den gibt es halt vor allen Dingen

01:03:03.470 --> 01:03:07.170
dafür, dass, wenn jetzt so zirkuläre, äh, Referenzen irgendwie, äh, so wenn das

01:03:07.170 --> 01:03:10.250
ein Objekt hat, das auf ein anderes verweist, das auf ein anderes verweist, das

01:03:10.250 --> 01:03:13.150
eine Referenz auf ein drittes hat und das wieder auf das erste oder so, dann...

01:03:13.150 --> 01:03:14.030
Die Katze beißt dich in den Schwanz.

01:03:14.030 --> 01:03:17.510
Ja, dann werden die durch Reference Counting nicht weggeräumt, dann muss man

01:03:17.510 --> 01:03:19.790
auch, muss auch Python ab und zu mal einen Garbage Collector anschmeißen, um

01:03:19.790 --> 01:03:21.210
solche Sachen zu finden und dann rauszuwerfen.

01:03:21.210 --> 01:03:22.150
Aber...

01:03:22.150 --> 01:03:25.030
Aber einen Garbage Collector kriegt man bei Python mit sowas wie Import DC dann, oder?

01:03:25.030 --> 01:03:25.850
Ja, genau, genau.

01:03:26.750 --> 01:03:30.130
Äh, und der macht manchmal auch blöde Sachen und auch da hat man dann halt

01:03:30.130 --> 01:03:32.290
manchmal so die Probleme, die man von anderen Programmiersprachen kennt.

01:03:32.290 --> 01:03:34.610
Also wenn man zum Beispiel, ich weiß nicht, ob das heute noch so ist, aber

01:03:34.610 --> 01:03:38.090
früher war das immer so, wenn man größere Datenmengen irgendwie importiert

01:03:38.090 --> 01:03:39.570
hat per CSV oder weiß ich nicht.

01:03:39.570 --> 01:03:43.590
Also ich habe früher irgendwie viel so, äh, Import-Export-Skripte auch

01:03:43.590 --> 01:03:48.390
geschrieben und, ähm, da war also einmal einer der Tricks halt, dass man, äh,

01:03:48.390 --> 01:03:50.990
quasi bevor man halt so ein paar Millionen, äh, Zeilen irgendwie gelesen

01:03:50.990 --> 01:03:53.170
hat und die irgendwo reingeschrieben hat in irgendeine Daten, Hauptspeicher

01:03:53.170 --> 01:03:56.470
Datenstruktur, ist halt, äh, einmal den, den Garbage Collector, äh,

01:03:56.750 --> 01:03:57.430
ausgeschaltet hat.

01:03:57.430 --> 01:03:59.550
Dann hat man den ganzen Scheiß importiert und dann hat man ihn wieder

01:03:59.550 --> 01:03:59.950
angeschaltet.

01:03:59.950 --> 01:04:04.990
Und, äh, weil ansonsten schlägt er halt alle paar tausend Zeilen oder so

01:04:04.990 --> 01:04:06.910
zu und, äh, blockiert alles.

01:04:06.910 --> 01:04:10.330
Und das macht es halt dann irgendwie direkt ein paar Faktoren schneller oder

01:04:10.330 --> 01:04:10.690
so, ne?

01:04:10.690 --> 01:04:13.230
Das, äh, heute kann sein, dass heute alles nicht mehr nötig ist und es

01:04:13.230 --> 01:04:15.570
besser geworden ist, aber, ja, also da...

01:04:15.570 --> 01:04:17.630
Ich bin echt neugierig, müssen wir vielleicht auch mal, äh, rausfinden,

01:04:17.630 --> 01:04:18.590
ob das wirklich noch so ist.

01:04:18.590 --> 01:04:19.130
Ja.

01:04:19.130 --> 01:04:21.190
Wenn man das wirklich immer machen muss, dass man im Müllwagen sagen muss,

01:04:21.190 --> 01:04:22.070
nee, heute nicht.

01:04:22.070 --> 01:04:22.790
Ja, genau.

01:04:22.790 --> 01:04:23.690
Und dann...

01:04:23.690 --> 01:04:26.450
Also wenn man weiß, was passiert, wenn man sagt, ich, so, ich hau jetzt eine

01:04:26.750 --> 01:04:29.470
Zeug, einen Hauptspeicher, ich weiß, dass es so ist und es ist richtig

01:04:29.470 --> 01:04:32.230
so, da muss nicht geguckt werden, ob das irgendwie jetzt, ob davon was

01:04:32.230 --> 01:04:34.090
weg kann, weil davon kann noch nichts weg, weil ich hab noch nichts

01:04:34.090 --> 01:04:37.730
anderes gemacht, dann kann ich halt sagen, okay, ja, da soll jetzt momentan

01:04:37.730 --> 01:04:40.470
nicht, äh, muss der Müllwagen nicht rumfahren, ne?

01:04:40.470 --> 01:04:42.570
Das ist, äh, eher sein Nachreden, ja.

01:04:42.570 --> 01:04:45.710
Aber ist natürlich schon hässlich, denn mit solchen Dingen will man sich

01:04:45.710 --> 01:04:48.570
eigentlich als, als, als Entwickler ja gar nicht so beschäftigen müssen,

01:04:48.570 --> 01:04:52.950
weil das ist natürlich irgendwie, ja, für die meisten Leute alles, äh...

01:04:52.950 --> 01:04:54.450
Ja, also ich glaube auch, unsere Anfänger haben wir gerade vielleicht

01:04:54.450 --> 01:04:55.130
wieder ein bisschen abgehängt.

01:04:55.130 --> 01:04:56.370
Ich hoffe, wir holen die noch wieder ein bisschen ein.

01:04:56.370 --> 01:04:56.730
Ich hoffe, wir...

01:04:56.730 --> 01:04:58.350
Ich finde das alles so interessant wie, äh, ich.

01:04:58.350 --> 01:05:01.950
Ähm, vielleicht kommen wir dann noch ein bisschen wieder zurück zu dem,

01:05:01.950 --> 01:05:03.970
äh, was wir jetzt durch hatten.

01:05:03.970 --> 01:05:05.770
Ich glaube, wir haben jetzt so ein bisschen erklärt, wie

01:05:05.770 --> 01:05:06.570
Python jetzt funktioniert.

01:05:06.570 --> 01:05:09.530
Ich weiß nicht, ob wir dazu noch ein bisschen was sagen möchten.

01:05:09.530 --> 01:05:10.590
Lass mich mal gerade überlegen.

01:05:10.590 --> 01:05:17.690
Also, äh, ja, äh, ne, ich glaube, äh, ja, nö, also im Grunde, im Grunde

01:05:17.690 --> 01:05:20.570
sind das so die wesentlichen Unterschiede zu anderen Programmiersprachen, ja.

01:05:20.570 --> 01:05:22.230
Ja, ja, okay.

01:05:22.230 --> 01:05:23.890
Das heißt, die Unterschiede haben wir jetzt so ein bisschen erklärt,

01:05:23.890 --> 01:05:25.290
was man damit also machen kann.

01:05:26.710 --> 01:05:28.270
Äh, vielleicht wollen wir ein bisschen noch drauf eingehen,

01:05:28.270 --> 01:05:29.710
was so die Mythen dieser Sprache sind.

01:05:29.710 --> 01:05:30.850
Also, ja, das ist total einfach.

01:05:30.850 --> 01:05:31.750
Ja.

01:05:31.750 --> 01:05:34.670
Ne, das ist immer so einer der Sachen, fand ich jetzt tatsächlich auch,

01:05:34.670 --> 01:05:35.630
also von der Syntax her.

01:05:35.630 --> 01:05:36.090
Ja.

01:05:36.090 --> 01:05:39.050
Da darf ich gut lasen, ja, dass du nicht irgendwie da standest und

01:05:39.050 --> 01:05:41.530
hast irgendwie wie ein C, so ein Hello World, wo es dann irgendwie über

01:05:41.530 --> 01:05:44.930
mehrere Teilen geht oder wie in Java, wo dann erst mal gucken muss,

01:05:44.930 --> 01:05:46.310
ah, wo geht denn jetzt diese Funktion hin?

01:05:46.310 --> 01:05:47.630
Steht da Print Hello World fertig?

01:05:47.630 --> 01:05:50.830
Genau, genau, ja, weil bei Java, da muss man dann erst irgendwie

01:05:50.830 --> 01:05:54.270
komische, so erst eine Klasse definieren und dann irgendwie, äh,

01:05:54.270 --> 01:05:56.690
Public, Static, Void, Main oder sowas hinschreiben, wo es dann

01:05:56.690 --> 01:05:59.090
Static, Void, Main ist halt so, irgendwie so magische Worte,

01:05:59.090 --> 01:06:01.310
damit irgendwas passiert, so, aber ein Python-Stamm einfach

01:06:01.310 --> 01:06:03.850
printen, wenn man printen möchte, das ist schon sehr nett, ja.

01:06:03.850 --> 01:06:07.090
Ähm, ja, äh.

01:06:07.090 --> 01:06:09.890
Also bleibt Python denn so einfach, wenn man das macht?

01:06:09.890 --> 01:06:10.830
Ja, ja, nein.

01:06:10.830 --> 01:06:15.090
Also, äh, ja, man kann auch.

01:06:15.090 --> 01:06:16.030
Kommt davon, was man damit machen will.

01:06:16.030 --> 01:06:17.190
Ja, ja, ja, man kann da auch.

01:06:17.190 --> 01:06:19.310
Man kann auch Netzwerkkram damit machen, das hatten wir noch.

01:06:19.310 --> 01:06:23.930
Ja, und, äh, ja, genau, und asynchrones Dinge und überhaupt,

01:06:23.930 --> 01:06:26.170
ja, da, da kann es auch dann relativ,

01:06:26.670 --> 01:06:27.410
fies werden.

01:06:27.410 --> 01:06:30.330
Das Dumme ist nur, das ist halt dann,

01:06:30.330 --> 01:06:32.170
wenn man fiese Probleme hat, dann, dann

01:06:32.170 --> 01:06:34.770
kann man da nicht viel dran tun, dann, äh,

01:06:34.770 --> 01:06:36.390
muss man leider, äh, leider manchmal

01:06:36.390 --> 01:06:38.310
den sauberen Apfel beißen, aber ich, ich meine,

01:06:38.310 --> 01:06:40.510
äh, es ist ja auch schön, wenn, wenn

01:06:40.510 --> 01:06:42.930
quasi, äh, schwierige

01:06:42.930 --> 01:06:44.590
Probleme möglich, äh, äh,

01:06:44.590 --> 01:06:45.910
schwierige Sachen möglich sind.

01:06:45.910 --> 01:06:49.010
Das macht einen mächtigen Tauberstab, ja, also noch mehr Magie, ja.

01:06:49.010 --> 01:06:50.770
Aber es gibt tatsächlich auch Situationen,

01:06:50.770 --> 01:06:52.310
wo man dann halt auch, äh,

01:06:52.310 --> 01:06:54.450
komplizierte Dinge tun, tun kann,

01:06:54.450 --> 01:06:56.650
beziehungsweise muss, und, ähm,

01:06:56.650 --> 01:06:58.910
ähm, ja, wo es manchmal auch nicht so richtig offensichtlich

01:06:58.910 --> 01:07:00.390
ist, was Python da, da tut.

01:07:00.390 --> 01:07:02.850
Ja, und es gibt halt

01:07:02.850 --> 01:07:04.590
auch so Ecken, die halt einfach nicht schön sind, das,

01:07:04.590 --> 01:07:05.690
das muss man natürlich auch sagen.

01:07:05.690 --> 01:07:08.670
Ich sag mal, wenn ihr jetzt einfach irgendwelche Daten von irgendwelchen Sensoren packen

01:07:08.670 --> 01:07:10.730
wollt in eine Datenbank, das ist ja dann relativ, äh,

01:07:10.730 --> 01:07:12.010
ja, für die meisten Sachen geht das, äh,

01:07:12.010 --> 01:07:15.330
ähm, genau, ja, also

01:07:15.330 --> 01:07:16.670
es ist einfach so,

01:07:16.670 --> 01:07:18.610
es ist, es ist, würde ich sagen, tatsächlich sehr, sehr

01:07:18.610 --> 01:07:20.550
einfach, es ist, es ist schön, wenn man irgendwie

01:07:20.550 --> 01:07:22.590
auf Stack Overflow schaut oder einfach googelt nach

01:07:22.590 --> 01:07:24.670
irgendwelchen, wie mache ich denn jetzt dies oder jenes,

01:07:24.670 --> 01:07:26.630
dann ist es toll, weil, äh,

01:07:26.630 --> 01:07:28.370
ja, das funktioniert halt meistens immer noch,

01:07:28.370 --> 01:07:30.470
selbst wenn der, wenn die Antwort, die irgendjemand gegeben hat,

01:07:30.470 --> 01:07:32.550
15 Jahre alt ist oder so. Es gibt tatsächlich auch

01:07:32.550 --> 01:07:34.930
relativ viele Antworten mittlerweile, das ist, äh,

01:07:34.930 --> 01:07:36.590
auch sehr angenehm, weil fast

01:07:36.590 --> 01:07:38.670
für alles, für jedes einzelne

01:07:38.670 --> 01:07:40.610
Problem, das man irgendwo hat, irgendjemand das schon mal

01:07:40.610 --> 01:07:42.510
hatte und irgendwie so eine Musterlösung findet oder

01:07:42.510 --> 01:07:44.650
auch das Problem dann von mehreren Seiten angucken

01:07:44.650 --> 01:07:46.410
kann und, ja.

01:07:46.410 --> 01:07:48.750
Aber, ja, genau, also das ist, äh,

01:07:48.750 --> 01:07:50.470
das Python einfach ist, würde ich sagen, ist ein

01:07:50.470 --> 01:07:52.530
Mythos, der durchaus irgendwie

01:07:52.530 --> 01:07:54.190
mehr Wahrheit als, äh, Mythos ist.

01:07:54.190 --> 01:07:56.530
Ähm, ja, ein

01:07:56.610 --> 01:07:58.590
andere Geschichte wäre halt irgendwie, oh,

01:07:58.590 --> 01:08:00.590
dieses Significant Widespace, das ist ja

01:08:00.590 --> 01:08:02.690
total furchtbar, das kann da, ich, da,

01:08:02.690 --> 01:08:03.870
ich kann so nicht arbeiten.

01:08:03.870 --> 01:08:06.530
Significant Widespace, für alle Leute, die

01:08:06.530 --> 01:08:08.610
jetzt gerade zum ersten Mal in der Sprache zuhören,

01:08:08.610 --> 01:08:10.630
ähm, bedeutet, dass tatsächlich, ähm,

01:08:10.630 --> 01:08:12.450
man darauf achten muss, wo was

01:08:12.450 --> 01:08:14.210
in dem Code steht von Python.

01:08:14.210 --> 01:08:16.650
Ja, dass man halt nicht, äh, quasi

01:08:16.650 --> 01:08:18.510
den Code beliebig formatieren kann, sondern, dass

01:08:18.510 --> 01:08:20.710
halt Widespace halt auch zur Syntax gehört.

01:08:20.710 --> 01:08:22.450
Also, dass, wenn ich jetzt, äh,

01:08:22.450 --> 01:08:24.690
ja, also, wenn ich eine

01:08:24.690 --> 01:08:26.590
Zeile, die im gleichen Block ist,

01:08:26.590 --> 01:08:28.490
äh, anders einrücke als die andere, dann

01:08:28.490 --> 01:08:30.750
geht das halt schief. Also, das, was, äh, ich sag mal,

01:08:30.750 --> 01:08:32.350
ein guter Programmierer von vornherein

01:08:32.350 --> 01:08:34.490
formatieren sollte in seinem Code, das, äh, sagt Python,

01:08:34.490 --> 01:08:36.230
wenn du es nicht machst, dann, äh, stürzt es ab und sagt,

01:08:36.230 --> 01:08:37.990
nee, nee, nee, du, aber nicht. Ja, genau.

01:08:37.990 --> 01:08:40.890
Ähm, ja.

01:08:40.890 --> 01:08:42.630
Und es ist natürlich doof,

01:08:42.630 --> 01:08:44.650
wenn man sich so ein anderes Schema angewohnt hat, irgendwann mal.

01:08:44.650 --> 01:08:46.490
Genau, äh, und man kann das halt nicht beliebig

01:08:46.490 --> 01:08:48.490
einstellen, ne, oder wenn man jetzt Tabs

01:08:48.490 --> 01:08:49.750
und Spaces mixt oder so,

01:08:49.750 --> 01:08:52.670
überhaupt, man kann Tabs auch verwenden zum Einrücken,

01:08:52.670 --> 01:08:54.630
aber das, äh, sollte man nicht tun, das ist böse.

01:08:54.630 --> 01:08:56.210
Immer schön Spaces verwenden.

01:08:56.570 --> 01:08:57.650
Leerzeichen pro Ebene.

01:08:57.650 --> 01:09:00.270
Und die meisten IDEs hier bauen

01:09:00.270 --> 01:09:02.390
das auch irgendwann um, das heißt, ihr könnt das so bauen, dass ihr dann

01:09:02.390 --> 01:09:04.310
vier Spaces pro Tab

01:09:04.310 --> 01:09:05.810
bekommt, da könnt ihr wieder im Tab arbeiten, aber

01:09:05.810 --> 01:09:08.370
es wird umgewandelt und ansonsten habt ihr tatsächlich manchmal Probleme,

01:09:08.370 --> 01:09:10.310
wenn ihr irgendwelchen Code Freunden schickt

01:09:10.310 --> 01:09:12.170
oder Code von Freunden bekommt, die haben Tabs benutzt

01:09:12.170 --> 01:09:14.170
und ihr leerzeichnet, dann funktioniert das nicht mehr und ihr

01:09:14.170 --> 01:09:16.150
seht nicht genau, warum, weil irgendwo

01:09:16.150 --> 01:09:18.730
irgendwelche Leerzeichen dazu führen, dass, äh,

01:09:18.730 --> 01:09:20.250
ja, da unterschiedlich interpretiert

01:09:20.250 --> 01:09:22.190
wird und dann stürzt das ganze Programm ab. Hässlich.

01:09:22.190 --> 01:09:24.090
Gerade für Anfänger manchmal, stehen

01:09:24.090 --> 01:09:26.310
davor und denken, was, warum, geht nicht.

01:09:26.550 --> 01:09:26.870
Ja.

01:09:26.870 --> 01:09:30.650
Also, ich würde sagen, so ein bisschen

01:09:30.650 --> 01:09:32.430
was ist ja da ja drin, also ich dachte

01:09:32.430 --> 01:09:34.490
auch am Anfang, also ich kam ja dann

01:09:34.490 --> 01:09:37.010
zu der Zeit, wo ich mich

01:09:37.010 --> 01:09:38.570
angefangen habe zu beschäftigen, auch von

01:09:38.570 --> 01:09:40.550
Perl her, wo man das halt nicht hat, wo man

01:09:40.550 --> 01:09:42.530
das kommentieren kann, wie man will und so, und ich dachte auch so,

01:09:42.530 --> 01:09:44.390
oh, das ist aber blöd, dass man da jetzt irgendwie, dass

01:09:44.390 --> 01:09:46.590
man darauf achten muss, aber das waren

01:09:46.590 --> 01:09:48.490
halt ein paar Tage und danach war's

01:09:48.490 --> 01:09:50.530
super und ich fand

01:09:50.530 --> 01:09:51.970
das nie wieder problematisch.

01:09:51.970 --> 01:09:53.190
Ähm,

01:09:53.190 --> 01:09:55.510
aber ich kann

01:09:55.510 --> 01:09:56.450
so ein bisschen verstehen, dass es,

01:09:56.530 --> 01:09:58.370
äh, blöd ist, wenn man das selber dafür sorgen muss, dass

01:09:58.370 --> 01:10:00.430
die, äh, äh, quasi,

01:10:00.430 --> 01:10:02.630
äh, dass die Formatierung

01:10:02.630 --> 01:10:04.670
so ist, dass die Syntax stimmt, äh,

01:10:04.670 --> 01:10:06.550
würde aber auch sagen, dass man

01:10:06.550 --> 01:10:08.330
das heute eigentlich nicht mehr macht. Also andere

01:10:08.330 --> 01:10:10.250
Sprachen machen ganz viele Klammern oder Semikolon

01:10:10.250 --> 01:10:12.490
oder sowas. Ja, das ist halt der, der, der Preis,

01:10:12.490 --> 01:10:14.270
den man dann zahlen muss, wenn man halt quasi eben nicht

01:10:14.270 --> 01:10:16.350
die Formatierung, äh, äh, Teil

01:10:16.350 --> 01:10:18.550
der Syntax, äh, als Teil der Syntax

01:10:18.550 --> 01:10:20.410
hat, sondern sagt, okay, du kannst formatieren,

01:10:20.410 --> 01:10:22.370
wie du willst, dann muss man halt irgendwie anders signalisieren,

01:10:22.370 --> 01:10:24.270
wo ein Blockanfängten aufhört. Und dann,

01:10:24.270 --> 01:10:25.810
dafür benutzt man halt typischerweise Klammern.

01:10:25.810 --> 01:10:26.510
Und das heißt,

01:10:26.530 --> 01:10:28.410
man hat halt sehr viele Klammern. Was halt,

01:10:28.410 --> 01:10:30.150
kann ich dir mal erzählen, fünf Klammern auf, sechs Klammern zu.

01:10:30.150 --> 01:10:32.310
Genau, genau. Und das ist halt auch

01:10:32.310 --> 01:10:34.190
nicht so richtig schön, ne. So ein Python ist

01:10:34.190 --> 01:10:36.270
diese Frage halt nie so, muss ich da jetzt noch eine Klammer,

01:10:36.270 --> 01:10:38.230
also, man hat sie auch an anderer

01:10:38.230 --> 01:10:40.250
Stelle, aber bei, jedenfalls nicht beim

01:10:40.250 --> 01:10:42.370
Schließen von Blöcken, so, muss ich da jetzt noch eine Klammer zumachen

01:10:42.370 --> 01:10:44.350
oder nicht, sondern, ne, wenn ich den jetzt da eingerückt

01:10:44.350 --> 01:10:46.070
habe und aufhöre, dann ist dieser Block vorbei.

01:10:46.070 --> 01:10:48.190
Das ist halt, äh, viel einfacher.

01:10:48.190 --> 01:10:50.050
Ähm, ja.

01:10:50.050 --> 01:10:52.430
Und, äh, genau, heutzutage

01:10:52.430 --> 01:10:54.430
auch schon gar nicht mehr so ein Problem,

01:10:54.430 --> 01:10:56.290
weil heute, würde ich sagen,

01:10:56.490 --> 01:10:58.210
sollte man Code eigentlich gar nicht mehr unbedingt

01:10:58.210 --> 01:11:00.290
selber formatieren, sondern man schreibt es halt

01:11:00.290 --> 01:11:02.110
irgendwie hin, dass man, man denkt, dass es halbwegs passt.

01:11:02.110 --> 01:11:04.510
Äh, und dann nimmt man

01:11:04.510 --> 01:11:06.510
halt sowas wie Black. Das ist jetzt so ein

01:11:06.510 --> 01:11:07.830
Ding, was halt... Black.

01:11:07.830 --> 01:11:10.350
Ja. Schwarz. Genau. Ja.

01:11:10.350 --> 01:11:11.990
Das ist so ein, äh,

01:11:11.990 --> 01:11:14.370
Kommandozeilen-Utility, äh, man kann

01:11:14.370 --> 01:11:16.390
das, äh, Wim-Plugin für den Editor

01:11:16.390 --> 01:11:18.290
oder so, und dem sagt man einfach nur,

01:11:18.290 --> 01:11:20.470
okay, reformatiere alles so, dass es

01:11:20.470 --> 01:11:22.570
irgendwie läuft, dem Standard entspricht

01:11:22.570 --> 01:11:24.350
und dann formatiert das den Code halt um.

01:11:24.350 --> 01:11:26.470
Aha. Und dann muss man da selber

01:11:26.470 --> 01:11:28.290
nichts mehr machen. Muss man das importieren, oder ist das

01:11:28.290 --> 01:11:30.850
ein Kommandozeilen-Tool? Das ist, das ist ein Kommandozeilen-Tool,

01:11:30.850 --> 01:11:32.350
aber, wie gesagt, es gibt für die meisten

01:11:32.350 --> 01:11:34.290
Editoren Plugins, die das dann halt aufmarschen.

01:11:34.290 --> 01:11:36.390
Diesen würde ich mir direkt mal aufschreiben, hier. Wieder was gelernt.

01:11:36.390 --> 01:11:37.570
Genau.

01:11:37.570 --> 01:11:40.290
Äh...

01:11:40.290 --> 01:11:42.230
Ja, also, ich würde sagen, heute,

01:11:42.230 --> 01:11:44.110
heutzutage sollte man eigentlich nicht mehr von Hand

01:11:44.110 --> 01:11:46.110
formatieren müssen, das ist, äh, macht man einfach nicht mehr.

01:11:46.110 --> 01:11:48.390
Ähm,

01:11:48.390 --> 01:11:50.490
genau, damit ist das im Grunde

01:11:50.490 --> 01:11:52.430
alles kein, kein Problem mehr, weil,

01:11:52.430 --> 01:11:54.830
äh, ja, man hat ja

01:11:54.830 --> 01:11:56.450
als Mensch gar nicht mehr damit zu tun, man muss

01:11:56.450 --> 01:11:57.230
sich gar nicht genau mehr drum machen.

01:11:57.230 --> 01:11:59.510
Man kann den Code in eine Zeile schreiben, das funktioniert weiterhin wunderbar.

01:11:59.510 --> 01:12:01.090
Ja, man kann tatsächlich

01:12:01.090 --> 01:12:02.890
relativ viel in eine Zeile schreiben, aber dann,

01:12:02.890 --> 01:12:04.670
Python muss man das dann auch signalisieren, dann schreibt man ein

01:12:04.670 --> 01:12:06.610
Semicolon, wenn man Statements voneinander erfahren möchte.

01:12:06.610 --> 01:12:08.830
Ja, das Semicolon gibt's auch in Python.

01:12:08.830 --> 01:12:11.330
Man muss es normalerweise nicht hinschreiben, weil der Zeilenumbruch

01:12:11.330 --> 01:12:12.810
das ist halt quasi gleiche...

01:12:12.810 --> 01:12:13.810
Aber wenn man es hinschreibt, tut's nichts.

01:12:13.810 --> 01:12:16.310
Wenn man es hinschreibt, da kann man auch alles in eine Zeile schreiben, ja, das geht.

01:12:16.310 --> 01:12:18.970
Nicht, dass man das wirklich tun sollte, aber...

01:12:18.970 --> 01:12:19.630
Das sieht ziemlich arg wie aus.

01:12:19.630 --> 01:12:23.250
Ja, äh, genau.

01:12:23.250 --> 01:12:25.450
Ja, also, das ist, ähm,

01:12:25.450 --> 01:12:26.390
das ist eine Geschichte,

01:12:26.550 --> 01:12:28.550
die halt immer wieder als, oh, das ist ja total schrecklich

01:12:28.550 --> 01:12:30.630
angebracht wird, aber ich würde sagen,

01:12:30.630 --> 01:12:32.930
einmal, sie ist nicht so schrecklich, und zum zweiten,

01:12:32.930 --> 01:12:35.050
heutzutage nicht mehr, kein Problem mehr eigentlich.

01:12:35.050 --> 01:12:36.930
Hier ist gerade der Piep, muss man eine Pflanze gießen jetzt, oder?

01:12:36.930 --> 01:12:38.370
Nee, meine, ich hab vergessen,

01:12:38.370 --> 01:12:40.730
meine Uhr zu sagen,

01:12:40.730 --> 01:12:43.230
dass sie nicht stören, dass sie nicht rumlaufen soll.

01:12:43.230 --> 01:12:44.190
Bei der Pieps-Goal, ja.

01:12:44.190 --> 01:12:45.210
Ja, und deswegen piepst es bei mir.

01:12:45.210 --> 01:12:47.210
Ich mach das gerade nicht auf lautlos.

01:12:47.210 --> 01:12:50.410
So, äh, und, ähm,

01:12:50.410 --> 01:12:52.730
eine andere Geschichte ist,

01:12:52.730 --> 01:12:54.390
ja, genau, Python ist langsam.

01:12:54.390 --> 01:12:56.230
Das ist auch immer etwas, was man halt hört.

01:12:56.410 --> 01:12:57.710
Äh, oh mein Gott, nein!

01:12:57.710 --> 01:12:59.170
Was tue ich jetzt?

01:12:59.170 --> 01:13:01.530
Ich bin viel schneller mit, äh,

01:13:01.530 --> 01:13:04.350
Ja, man muss irgendwie das in Go neu schreiben,

01:13:04.350 --> 01:13:05.990
oder in, keine Ahnung, oder in C,

01:13:05.990 --> 01:13:08.190
oder C++, viel besser, weil viel schneller.

01:13:08.190 --> 01:13:09.190
Und, ist es langsam?

01:13:09.190 --> 01:13:11.450
Äh, ja und nein.

01:13:11.450 --> 01:13:13.810
Also, es kommt halt tatsächlich,

01:13:13.810 --> 01:13:15.650
also man kann, solche pauschalen,

01:13:15.650 --> 01:13:18.390
äh, äh, Urteile sind halt

01:13:18.390 --> 01:13:20.070
immer falsch eigentlich,

01:13:20.070 --> 01:13:21.910
deswegen, weil man das,

01:13:21.910 --> 01:13:24.350
ja, man muss halt immer, äh,

01:13:24.350 --> 01:13:26.150
quasi konkret sagen, was man damit meint,

01:13:26.150 --> 01:13:26.390
wenn man, äh,

01:13:26.390 --> 01:13:28.050
wenn man jetzt sagt, dass es schnell oder langsam,

01:13:28.050 --> 01:13:29.230
und halt in einem bestimmten Kontext,

01:13:29.230 --> 01:13:30.850
in einem bestimmten Kontext geben,

01:13:30.850 --> 01:13:31.950
und dann kann man das halt sagen.

01:13:31.950 --> 01:13:33.290
Also, ich könnte zum Beispiel sagen,

01:13:33.290 --> 01:13:36.870
also, wenn ich, wenn ich Methoden aufrufe

01:13:36.870 --> 01:13:38.770
in Python, dann dauert das,

01:13:38.770 --> 01:13:40.510
ist das halt deutlich langsamer als jetzt

01:13:40.510 --> 01:13:41.530
in C++ zum Beispiel.

01:13:41.530 --> 01:13:43.010
Das ist tatsächlich so.

01:13:43.010 --> 01:13:44.090
Oder wenn ich eine Funktion aufrufe in C,

01:13:44.090 --> 01:13:45.810
ist es viel schneller als, als in Python.

01:13:45.810 --> 01:13:48.330
Ähm, also wenn ich halt eine Vorschleife mache

01:13:48.330 --> 01:13:49.650
und dann tausendmal eine Methode aufrufe

01:13:49.650 --> 01:13:50.410
auf einer Klasse oder so,

01:13:50.410 --> 01:13:51.770
dann ist das in Python viel, viel langsamer

01:13:51.770 --> 01:13:53.130
als in C oder in C++.

01:13:53.130 --> 01:13:56.270
Insofern, äh,

01:13:56.270 --> 01:13:58.010
in diesem Kontext wäre Python tatsächlich sehr langsam.

01:13:58.010 --> 01:14:00.310
Aber die Frage ist halt,

01:14:00.310 --> 01:14:01.670
was man, was ein Programm so tut.

01:14:01.670 --> 01:14:03.870
Und wenn ich jetzt zum Beispiel irgendwie

01:14:03.870 --> 01:14:06.050
große Matrizen mit dem Alter multipliziere, ja,

01:14:06.050 --> 01:14:08.730
und ich mach das halt irgendwie mit zwei NumPy-Arrays

01:14:08.730 --> 01:14:10.230
in Python, ja,

01:14:10.230 --> 01:14:11.610
wo die Syntax sehr schick ist,

01:14:11.610 --> 01:14:13.130
und ich das in einer Zeile tue,

01:14:13.130 --> 01:14:16.270
und ich, äh, äh, jemand anders überlegt sich,

01:14:16.270 --> 01:14:17.590
hat gehört, Python ist langsam,

01:14:17.590 --> 01:14:18.610
und macht das halt in C,

01:14:18.610 --> 01:14:20.950
mit so einer dreifach verschachtelten For-Loop

01:14:20.950 --> 01:14:22.830
über halt, äh, irgendwelche Datenstrukturen,

01:14:22.830 --> 01:14:24.590
weiß ich nicht, irgendwie so ein Type-Memory-View,

01:14:24.590 --> 01:14:26.010
oder wo, wo auch immer man das in C,

01:14:26.150 --> 01:14:26.810
wie man das in C hält.

01:14:26.810 --> 01:14:28.230
Das ist ja ziemlich viele Zeilen lang, ja.

01:14:28.230 --> 01:14:33.010
Äh, dann wird die C-Implementation

01:14:33.010 --> 01:14:35.270
deutlich lang, wird halt deutlich langsamer sein

01:14:35.270 --> 01:14:36.910
als die Matrizen-Multiplikation

01:14:36.910 --> 01:14:38.690
in, in Python, die halt

01:14:38.690 --> 01:14:40.690
man in eine Zeile schreiben kann, wo man einfach nur schreibt

01:14:40.690 --> 01:14:42.150
A mal B, ja.

01:14:42.150 --> 01:14:44.730
Also C gleich A mal B, ja.

01:14:44.730 --> 01:14:47.050
Und das könnte jetzt für manche Leute

01:14:47.050 --> 01:14:47.750
überraschend sein, weil

01:14:47.750 --> 01:14:50.790
wenn, wenn quasi sich jemand

01:14:50.790 --> 01:14:52.350
die Mühe gemacht hat, irgendein Problem,

01:14:52.350 --> 01:14:54.770
äh, also wirklich da so das letzte Kränzchen

01:14:54.770 --> 01:14:55.810
Performance rauszuoptimieren,

01:14:56.030 --> 01:14:58.130
und es eine Bibliothek gibt, die halt

01:14:58.130 --> 01:15:00.250
dieses Verfahren dann benutzt,

01:15:00.250 --> 01:15:02.490
sozusagen in Python, und man das in Python

01:15:02.490 --> 01:15:04.230
benutzen kann, dann ist das halt auch in Python sehr schnell.

01:15:04.230 --> 01:15:06.930
Und, äh, grad diese ganzen Berechnungsgeschichten,

01:15:06.930 --> 01:15:08.870
Certific Computing-Zeugs,

01:15:08.870 --> 01:15:10.690
das ist halt alles sehr schnell

01:15:10.690 --> 01:15:11.110
in Python.

01:15:11.110 --> 01:15:13.650
Wie heißt das, C-Types, oder?

01:15:13.650 --> 01:15:16.530
Nein, nee, C-Types ist nochmal

01:15:16.530 --> 01:15:17.250
eine andere...

01:15:17.250 --> 01:15:18.870
Entschuldigt, bitte.

01:15:18.870 --> 01:15:22.410
Es ist auch so, dass man quasi relativ einfach,

01:15:22.410 --> 01:15:24.050
äh, nein, also

01:15:24.050 --> 01:15:25.910
eine Geschichte, mit der man dann halt

01:15:25.910 --> 01:15:28.130
gut optimieren kann, ist auch

01:15:28.130 --> 01:15:30.270
sowas wie CYTON zum Beispiel. Also C-Types ist nochmal

01:15:30.270 --> 01:15:31.790
eher zum Anbieten von irgendwelchen

01:15:31.790 --> 01:15:33.230
C-Bibliotheken, aber

01:15:33.230 --> 01:15:36.250
äh, äh, es gibt sowas

01:15:36.250 --> 01:15:38.070
wie, das hatten wir, das haben wir vergessen.

01:15:38.070 --> 01:15:39.930
Das müssen wir vielleicht gleich nochmal, äh,

01:15:39.930 --> 01:15:41.730
es gibt nicht nur den Python, äh, den

01:15:41.730 --> 01:15:43.790
C-Python-Interpreter,

01:15:43.790 --> 01:15:46.170
es gibt auch andere Python-Interpreter, und es gibt

01:15:46.170 --> 01:15:47.650
halt auch so Dinge wie CYTON, die

01:15:47.650 --> 01:15:50.430
Python, beziehungsweise Python-ähnlichen

01:15:50.430 --> 01:15:51.810
Code nehmen und den

01:15:51.810 --> 01:15:53.690
in C verwandeln.

01:15:53.690 --> 01:15:55.790
Ja, also das haben wir ja gar nicht vergessen.

01:15:55.790 --> 01:15:57.550
Wir erklären das doch einfach jetzt. Genau, genau.

01:15:57.550 --> 01:15:59.890
Äh, wenn ich, wenn ich jetzt irgendwas schneller machen

01:15:59.890 --> 01:16:01.710
möchte, dann gibt's halt die Möglichkeit, okay, ich schreibe

01:16:01.710 --> 01:16:03.550
das jetzt einfach in C und, äh,

01:16:03.550 --> 01:16:05.830
muss mich da an ein paar Konventionen halten,

01:16:05.830 --> 01:16:07.790
dann kompiliere ich das und dann, äh,

01:16:07.790 --> 01:16:09.850
quasi importiere ich, kann ich das

01:16:09.850 --> 01:16:11.670
halt in Python auch wieder importieren,

01:16:11.670 --> 01:16:13.450
als wäre es ein Python-Modul oder so, und dann halt verwenden.

01:16:13.450 --> 01:16:15.750
Aber ich schreibe einfach C-Code und

01:16:15.750 --> 01:16:17.910
dann wird dann Python geladen, ich benutze die Python-Syntax

01:16:17.910 --> 01:16:19.710
und bin schnell dabei, oder? Ja, ja, ja,

01:16:19.710 --> 01:16:21.290
so ungefähr, das ist halt ein bisschen Arbeit,

01:16:21.290 --> 01:16:23.970
aber das geht. Ähm,

01:16:23.970 --> 01:16:25.670
äh, und

01:16:25.670 --> 01:16:27.990
das ist vor allen Dingen halt auch so ein bisschen, man muss sich da einlesen,

01:16:27.990 --> 01:16:29.730
wie man das, wie man so ein, so ein C-Modul schreibt

01:16:29.730 --> 01:16:31.230
und so, ähm,

01:16:31.230 --> 01:16:33.870
aber was man auch machen kann,

01:16:33.870 --> 01:16:35.530
ist, man schreibt halt ein, äh,

01:16:35.530 --> 01:16:37.130
das, was man, was auch immer man machen möchte,

01:16:37.130 --> 01:16:39.490
äh, in einem Python-ähnlichen

01:16:39.490 --> 01:16:41.410
Dialekt, äh,

01:16:41.410 --> 01:16:43.450
wo man halt auch,

01:16:43.450 --> 01:16:45.650
man kann einfach so Python hinschreiben.

01:16:45.650 --> 01:16:47.430
Python-ähnlicher Direkt, das haben wir ja schon ganz viel

01:16:47.430 --> 01:16:49.610
Programmiersprache, es gibt ja nur noch Dialekte, also wird ja immer besser.

01:16:49.610 --> 01:16:51.750
Äh, man kann, also der wesentliche Unterschied ist,

01:16:51.750 --> 01:16:53.510
dass man dazu schreiben kann, was die Typen sind, dass man

01:16:53.510 --> 01:16:55.430
zum Beispiel schreibt, also dies ist jetzt ein Integer,

01:16:55.550 --> 01:16:57.050
oder das hier ist ein Float,

01:16:57.050 --> 01:16:59.590
und so. Ja, also man schreibt halt quasi noch

01:16:59.590 --> 01:17:01.530
Typen mit zu

01:17:01.530 --> 01:17:03.310
den Variablen. Wie wir das eben schon hatten, also

01:17:03.310 --> 01:17:05.290
das mit der neuen Version jetzt schon so drin ist,

01:17:05.290 --> 01:17:07.470
genau, so kann man das auch machen. Es gibt Type-Annotationen, aber die sind halt leider noch mal was anderes,

01:17:07.470 --> 01:17:09.290
das funktioniert nicht mit Type-Annotationen.

01:17:09.290 --> 01:17:11.410
Okay, das heißt, nochmal ein bisschen umdrehen. Ja, könnte man

01:17:11.410 --> 01:17:13.150
vielleicht irgendwann auch machen, das gibt's aber noch nicht.

01:17:13.150 --> 01:17:15.490
Äh, jedenfalls, wenn man das,

01:17:15.490 --> 01:17:17.530
wenn man das jetzt so hingeschrieben hat,

01:17:17.530 --> 01:17:19.490
äh, in diesem Dialekt, der sehr einfach ist

01:17:19.490 --> 01:17:21.350
und aussieht wie Python

01:17:21.350 --> 01:17:23.390
quasi, äh, mit, mit Typen

01:17:23.390 --> 01:17:25.430
dran, äh, dann kann man das

01:17:25.430 --> 01:17:27.590
in C kompilieren, und zwar

01:17:27.590 --> 01:17:29.490
in, in C, dass halt man dann hinterher

01:17:29.490 --> 01:17:31.190
wieder so kompilieren kann, dass es ein

01:17:31.190 --> 01:17:33.390
C-Modul ist, das man dann wieder importieren kann.

01:17:33.390 --> 01:17:35.670
Ja, so dass man halt das eigentliche C nie

01:17:35.670 --> 01:17:37.900
muss eigentlich nur Python, kleiner Gelekt schreiben

01:17:37.900 --> 01:17:39.640
und schon ist es C und dann

01:17:39.640 --> 01:17:41.860
wird es schnell, so schnell wie C

01:17:41.860 --> 01:17:43.280
und ist dann so schnell wie C

01:17:43.280 --> 01:17:45.720
Problem gelöst, würde ich sagen

01:17:45.720 --> 01:17:47.460
genau, und das ist halt schon sehr cool, das kann man sogar

01:17:47.460 --> 01:17:49.740
in Jupyter Notebooks, kann man das als

01:17:49.740 --> 01:17:51.560
Cell Magic, kann man das schreibt man einfach Prozent

01:17:51.560 --> 01:17:53.660
Prozent Zeiten, schreibt dann halt irgendwie

01:17:53.660 --> 01:17:55.380
die Funktionen rein mit

01:17:55.380 --> 01:17:57.660
Annotationen, das ist der Typen und dann hat man etwas, was

01:17:57.660 --> 01:17:59.740
halt so schnell wie C ist, halt direkt

01:17:59.740 --> 01:18:01.800
so ohne, dass man das irgendwie neu starten muss oder so

01:18:01.800 --> 01:18:03.720
einfach so da, das ist halt schon

01:18:03.720 --> 01:18:05.200
sehr, das sind

01:18:05.200 --> 01:18:06.680
ja, also ich meine

01:18:06.680 --> 01:18:09.740
wenn man solche Sachen Leuten zeigt, die sagen Python ist langsam

01:18:09.740 --> 01:18:11.180
dann, oh

01:18:11.180 --> 01:18:13.440
genau, also

01:18:13.440 --> 01:18:15.700
man kann, wenn man es drauf anlegt, kann man

01:18:15.700 --> 01:18:17.780
sehr schnell werden, auch in diesen

01:18:17.780 --> 01:18:19.620
Geschichten kann man halt auch diesen Global

01:18:19.620 --> 01:18:21.160
Interpreter Log deaktivieren, dann

01:18:21.160 --> 01:18:23.620
kann man halt sagen, so okay, ich weiß ja genau, was ich tue, ich

01:18:23.620 --> 01:18:24.300
deaktiviere das Ding

01:18:24.300 --> 01:18:27.660
also da ist das alles nicht mehr so

01:18:27.660 --> 01:18:28.020
relevant

01:18:28.020 --> 01:18:31.900
also da kann ich dann auch mit mehreren Kernen rechnen

01:18:31.900 --> 01:18:33.560
genau, da kann ich dann auch quasi

01:18:33.560 --> 01:18:34.960
das, was ich tun möchte, auf mehrere Prozessoren

01:18:34.960 --> 01:18:37.000
verteilen, passiert auch

01:18:37.000 --> 01:18:39.020
also wenn ich jetzt irgendwie, keine Ahnung, eben eine Matrizen

01:18:39.020 --> 01:18:40.640
Multiplikation, jetzt weiß ich gar nicht, ob das meine

01:18:40.640 --> 01:18:42.920
wenn ich irgendwelche Dinge auf NumPy Arrays mache

01:18:42.920 --> 01:18:44.820
oder in Pandas mache, manchmal

01:18:44.820 --> 01:18:47.020
ja, nicht immer, verteilt es dann halt

01:18:47.020 --> 01:18:49.020
den Kram automatisch halt auf

01:18:49.020 --> 01:18:50.980
alle Prozessoren, die ich da habe

01:18:50.980 --> 01:18:53.140
ja, ansonsten gibt es

01:18:53.140 --> 01:18:55.000
auch jede Menge schöne Bibliotheken, die man da benutzen

01:18:55.000 --> 01:18:56.160
kann für Data Science

01:18:56.160 --> 01:18:58.260
Geschichten, ist da halt zum Beispiel

01:18:58.260 --> 01:19:00.440
Dask sehr zu empfehlen, kann man sagen

01:19:00.440 --> 01:19:02.900
Dask, ja, heißt so

01:19:02.900 --> 01:19:04.880
Data Ask, Dask, ich weiß, ich weiß

01:19:04.880 --> 01:19:06.360
gar nicht genau, wofür das steht

01:19:06.360 --> 01:19:09.040
Dask, nur D

01:19:09.040 --> 01:19:10.860
Da ist ein Dask

01:19:10.860 --> 01:19:14.800
Ja, genau

01:19:14.800 --> 01:19:15.960
und

01:19:15.960 --> 01:19:18.960
ja, es gibt auch so, da gibt es noch diverse andere

01:19:18.960 --> 01:19:20.220
Geschichten, es gibt zum Beispiel Number

01:19:20.220 --> 01:19:23.040
das ist halt ein Dekorator, den schreibt man

01:19:23.040 --> 01:19:24.400
drüber und dann macht das halt so

01:19:24.400 --> 01:19:27.000
Just-in-Time-Kompilierung, wie man das halt auch

01:19:27.000 --> 01:19:28.120
von Java vielleicht kennt

01:19:28.120 --> 01:19:31.000
das kann Dinge auch total

01:19:31.000 --> 01:19:32.580
beschleunigen, da muss man gar nichts ändern, also

01:19:32.580 --> 01:19:34.600
auch da kann man dann wieder Typen dazuschreiben oder so

01:19:34.600 --> 01:19:36.800
aber auch da, oft ist es so, man

01:19:36.800 --> 01:19:38.840
schreibt das einfach drüber und die Funktion wird viel, viel schneller

01:19:38.840 --> 01:19:40.500
und

01:19:40.500 --> 01:19:41.640
PyPy oder sowas habe ich noch

01:19:41.640 --> 01:19:44.900
genau, das ist ein anderer Interpreter, den man verwenden kann

01:19:44.900 --> 01:19:46.380
der hat dann diverse Probleme, nicht halt

01:19:46.380 --> 01:19:50.320
der macht auch so

01:19:50.320 --> 01:19:52.700
Just-in-Time-Kompilierungsgeschichten

01:19:52.700 --> 01:19:54.600
und so, und ist dadurch

01:19:54.600 --> 01:19:56.780
viel schneller, PyPy ist ein bisschen problematisch

01:19:56.780 --> 01:19:57.980
das hat irgendwie

01:19:57.980 --> 01:20:00.680
ist nicht mehr so auf der aktuellsten Version

01:20:00.680 --> 01:20:01.840
von Python und

01:20:01.840 --> 01:20:04.520
ist so ein bisschen leidet darunter, dass da nicht so genug Leute

01:20:04.520 --> 01:20:05.180
dabei sind

01:20:05.180 --> 01:20:09.760
es gibt auch

01:20:09.760 --> 01:20:10.720
Stackless-Python

01:20:10.720 --> 01:20:12.820
also es gibt noch diverse andere Interpreter

01:20:12.820 --> 01:20:14.360
es gibt nicht nur den C-Python-Interpreter

01:20:14.360 --> 01:20:17.100
aber man muss schon sagen, der C-Python-Interpreter

01:20:17.100 --> 01:20:18.640
ist natürlich eigentlich derjenige, den

01:20:18.640 --> 01:20:20.420
die Leute so verwenden und den man halt kennt

01:20:20.420 --> 01:20:22.600
und auch die Referenz-Implementation

01:20:22.600 --> 01:20:24.180
aber wenn man jetzt

01:20:24.180 --> 01:20:26.460
in einem bestimmten Szenario mehr Performance braucht, dann kann es

01:20:26.460 --> 01:20:28.620
durchaus sinnvoll sein, da halt sowas wie PyPy zu sein

01:20:28.620 --> 01:20:30.480
also trau niemals den Benchmark, so wie ich

01:20:30.480 --> 01:20:31.060
selbst gefälscht habe

01:20:31.060 --> 01:20:33.800
ja, genau

01:20:33.800 --> 01:20:34.440
ja, genau

01:20:34.440 --> 01:20:36.080
ja, das ist auch so einer der Mythen

01:20:36.080 --> 01:20:38.480
irgendwie Python ist langsam, was haben wir denn noch so

01:20:38.480 --> 01:20:44.220
ja

01:20:44.220 --> 01:20:46.800
also wir wissen, dass

01:20:46.800 --> 01:20:48.360
Python jetzt einfach ist, wir wissen, dass

01:20:48.360 --> 01:20:50.220
Python nicht langsam ist

01:20:50.220 --> 01:20:52.620
oder nicht langsam sein muss

01:20:52.620 --> 01:20:54.500
wir wissen, dass man für Python ja trotzdem ganz viele

01:20:54.500 --> 01:20:56.380
mächtige Werkzeuge benutzen kann, wenn man dann

01:20:56.380 --> 01:20:57.800
irgendwann mal gelernt hat, wie

01:20:57.800 --> 01:21:00.560
ja

01:21:00.560 --> 01:21:03.000
fällt dir noch was ein?

01:21:04.440 --> 01:21:06.900
nö, zu hart

01:21:06.900 --> 01:21:09.800
warum hat Python so lange gebraucht, bis es sich so

01:21:09.800 --> 01:21:11.200
durchsetzte, was glaubst du?

01:21:11.200 --> 01:21:13.820
das ist eine gute Frage, also ich hätte damit auch gar nicht

01:21:13.820 --> 01:21:15.140
gerechnet, dass es jetzt passiert, also wenn mich jemand

01:21:15.140 --> 01:21:17.740
quasi am Anfang

01:21:17.740 --> 01:21:19.800
meiner Python-Begeisterung gefragt hätte, ob ich glaube

01:21:19.800 --> 01:21:21.660
dass sich das mal so durchsetzt, dann hätte ich gesagt

01:21:21.660 --> 01:21:23.660
ja, auf jeden Fall, und ich hätte wahrscheinlich

01:21:23.660 --> 01:21:25.800
geschätzt, dass es viel weniger lang

01:21:25.800 --> 01:21:26.180
dauert

01:21:26.180 --> 01:21:31.580
und jetzt da angekommen ist, sagst du, es gibt auch gar keine Alternative

01:21:31.580 --> 01:21:33.960
also auch Go, sagst du, das war ganz fancy stuff

01:21:33.960 --> 01:21:34.280
aber

01:21:34.280 --> 01:21:35.680
nein, das ist auch alles schön, also ich meine

01:21:35.680 --> 01:21:37.820
ich finde Go auch toll, ich finde auch Rust toll

01:21:37.820 --> 01:21:39.600
das hat alles schon so auch

01:21:39.600 --> 01:21:41.660
vor allen Dingen andere Trade-offs

01:21:41.660 --> 01:21:43.800
und ich meine, gut, das sind auch alles manchmal so sehr viel

01:21:43.800 --> 01:21:45.900
modernere, also ich würde sagen, Go ist stark

01:21:45.900 --> 01:21:47.760
die Go-Syntax ist sehr stark inspiriert

01:21:47.760 --> 01:21:48.220
von Python

01:21:48.220 --> 01:21:51.720
die also

01:21:51.720 --> 01:21:53.900
ja, sind teilweise

01:21:53.900 --> 01:21:55.780
sehr, sehr viel, also sowohl

01:21:55.780 --> 01:21:57.420
Go wie auch Rust sind halt sehr viel jünger als

01:21:57.420 --> 01:21:58.400
Python, insofern

01:21:58.400 --> 01:22:01.520
ist das halt auch vielleicht nicht unbedingt direkt

01:22:01.520 --> 01:22:03.600
miteinander vergleichbar, aber

01:22:04.120 --> 01:22:06.260
Go ist halt einen schmaleren

01:22:06.260 --> 01:22:08.280
Einsatzzweck, würde ich jetzt mal so

01:22:08.280 --> 01:22:09.040
denken

01:22:09.040 --> 01:22:11.240
vielleicht erinnert sich das auch noch irgendwann

01:22:11.240 --> 01:22:12.960
und zwar, also wofür würdest du jetzt Go benutzen?

01:22:12.960 --> 01:22:16.280
naja, Systemprogrammierung und halt Sachen, wo man

01:22:16.280 --> 01:22:19.500
quasi

01:22:19.500 --> 01:22:21.820
viel I.O. hat und

01:22:21.820 --> 01:22:23.560
viel CPU braucht

01:22:23.560 --> 01:22:26.120
das ist

01:22:26.120 --> 01:22:29.700
also wenn man jetzt zum Beispiel sowas wie einen Datenbank-Server schreiben will

01:22:29.700 --> 01:22:31.440
oder so, wobei ich nicht weiß, ob Go da wirklich

01:22:31.440 --> 01:22:33.960
also ich weiß auch nicht, ob das jemand schon mal gemacht hat, aber das könnte man

01:22:33.960 --> 01:22:34.480
eventuell tun

01:22:34.480 --> 01:22:36.300
also

01:22:36.300 --> 01:22:38.800
viel Sachen machen muss, heißt tatsächlich

01:22:38.800 --> 01:22:40.200
Input-Output die ganze Zeit

01:22:40.200 --> 01:22:43.180
Input-Output plus irgendwie viel CPU braucht

01:22:43.180 --> 01:22:44.560
also wenn man nur Input-Output machen muss

01:22:44.560 --> 01:22:46.960
und I.O. multiplexen, das geht in Python auch total super

01:22:46.960 --> 01:22:48.520
dann nimmt man Async.io oder

01:22:48.520 --> 01:22:50.760
die neuen Frameworks, die es da gibt

01:22:50.760 --> 01:22:52.700
weiß ich nicht, Trio da

01:22:52.700 --> 01:22:53.220
oder

01:22:53.220 --> 01:22:55.760
was auch immer

01:22:55.760 --> 01:22:58.460
Trio von David Beasley

01:22:58.460 --> 01:23:00.640
von der Europython, das war auch sehr toll, aber ich glaube

01:23:00.640 --> 01:23:02.800
das ist nur ein Dialekt von Async.io

01:23:02.800 --> 01:23:03.800
Ja,

01:23:03.800 --> 01:23:05.820
genau, die sind auch relativ

01:23:05.820 --> 01:23:06.920
kompatibel irgendwie zueinander

01:23:06.920 --> 01:23:08.840
das ist

01:23:08.840 --> 01:23:11.680
genau, damit geht das auch alles total super

01:23:11.680 --> 01:23:13.400
dafür brauche ich jetzt nicht

01:23:13.400 --> 01:23:15.000
da

01:23:15.000 --> 01:23:17.440
ist der

01:23:17.440 --> 01:23:18.840
GIL nicht unbedingt ein Problem

01:23:18.840 --> 01:23:21.020
der Global Interpreter-Log

01:23:21.020 --> 01:23:23.560
ich kann auch mehrere Prozesse starten oder so

01:23:23.560 --> 01:23:25.560
aber wenn ich jetzt sowas habe wie eine Datenbank

01:23:25.560 --> 01:23:27.820
oder so, dann ist das mit mehreren Prozessen unter Umständen

01:23:27.820 --> 01:23:28.600
blöd, wenn ich jetzt

01:23:28.600 --> 01:23:31.360
also da könnte es sein, dass es sinnvoll ist

01:23:31.360 --> 01:23:33.220
also, dass ich halt

01:23:33.220 --> 01:23:33.640
ein Prozess starte und dann

01:23:33.640 --> 01:23:35.320
einen Prozess habe, der halt auf vielen

01:23:35.320 --> 01:23:37.080
Prozessoren läuft und dann auch

01:23:37.080 --> 01:23:38.840
I.O. mäßig irgendwie ganz viel nach draußen macht

01:23:38.840 --> 01:23:40.620
und da wäre Go wahrscheinlich super

01:23:40.620 --> 01:23:43.340
ja, oder Rust hat halt auch

01:23:43.340 --> 01:23:45.040
schöne Eigenschaften, dass halt da irgendwie

01:23:45.040 --> 01:23:47.080
diverse Sachen garantiert sind

01:23:47.080 --> 01:23:48.620
zur Compile-Zeit, das ist halt toll

01:23:48.620 --> 01:23:50.820
ja, aber

01:23:50.820 --> 01:23:53.080
Moment, jetzt musst du nochmal kurz erklären

01:23:53.080 --> 01:23:55.540
sind die Sachen garantiert zur Compile-Zeit

01:23:55.540 --> 01:23:56.920
da die bei Python nicht sind

01:23:56.920 --> 01:23:58.960
da musst du jetzt ganz kurz nochmal versuchen

01:23:58.960 --> 01:24:01.340
das so zusammenzufassen, das habe ich jetzt nämlich noch nicht so ganz

01:24:01.340 --> 01:24:03.560
durchblickt. Ach, ich weiß nicht, vielleicht würde das auch ein bisschen

01:24:03.560 --> 01:24:04.860
zu weit, also bei

01:24:04.860 --> 01:24:07.620
Rust ist es halt so, dass man quasi

01:24:07.620 --> 01:24:09.380
garantieren kann, dass es keine Speicher-Lags gibt und so

01:24:09.380 --> 01:24:13.160
bei Python sollte das jetzt auch nicht passieren

01:24:13.160 --> 01:24:15.300
wenn man das schafft, irgendwie

01:24:15.300 --> 01:24:17.600
außer dadurch den Speicher wirklich zu

01:24:17.600 --> 01:24:19.220
verbrauchen, also wenn man einfach nur irgendwas macht

01:24:19.220 --> 01:24:21.500
also irgendwas erzeugt, irgendwas wieder

01:24:21.500 --> 01:24:23.200
wegschmeißt und trotzdem

01:24:23.200 --> 01:24:25.260
quasi der Prozess

01:24:25.260 --> 01:24:27.620
der Speicher des Prozesses, den man da halt gestartet hat

01:24:27.620 --> 01:24:29.440
immer größer wird, dann hat man halt einen Bug

01:24:29.440 --> 01:24:31.580
gefunden, also gibt es natürlich auch

01:24:31.580 --> 01:24:33.480
immer wieder, sollte

01:24:33.480 --> 01:24:34.680
aber auch nicht passieren in Python

01:24:34.680 --> 01:24:37.220
aber es gibt da nicht so harte Garantien

01:24:37.220 --> 01:24:39.460
also das ist, und man kann es

01:24:39.460 --> 01:24:40.200
auch kaputt machen, wenn man

01:24:40.200 --> 01:24:43.280
irgendwelchen Unsinn anstellen, einen Gabel-Projektor importieren

01:24:43.280 --> 01:24:44.940
dann drauf referenzieren auf die Objekte, die man da findet

01:24:44.940 --> 01:24:47.160
ja, man kann da beliebig

01:24:47.160 --> 01:24:49.400
kaputte Sachen natürlich machen

01:24:49.400 --> 01:24:51.660
genau

01:24:51.660 --> 01:24:53.280
ja

01:24:53.280 --> 01:24:55.660
aber diesen Anwendungsfall

01:24:55.660 --> 01:24:57.680
dass man viel I.O. und viel Prozessor

01:24:57.680 --> 01:24:59.140
gleichzeitig braucht, den haben glaube ich

01:24:59.140 --> 01:25:01.340
gar nicht so viele Leute, insofern ist es halt auch so

01:25:01.340 --> 01:25:03.400
dass ich finde, dass der richtige

01:25:03.400 --> 01:25:05.160
Schritt sozusagen, oder das, ich finde

01:25:05.160 --> 01:25:07.440
das ist ein sehr netter Punkt

01:25:07.440 --> 01:25:09.480
quasi, man hat, wenn man jetzt Reference-Counting

01:25:09.480 --> 01:25:11.240
in Python hat

01:25:11.240 --> 01:25:12.980
man hat halt gute

01:25:12.980 --> 01:25:15.380
Single-Thread-Performance, man hat sehr gutartiges

01:25:15.380 --> 01:25:16.980
Latenzverhalten, das alles

01:25:16.980 --> 01:25:18.560
verhält sich alles sehr schön

01:25:18.560 --> 01:25:21.480
gut verlierbar

01:25:21.480 --> 01:25:23.260
damit dann auch, genau, opfert damit

01:25:23.260 --> 01:25:25.280
halt sozusagen, dass es auf mehreren Prozessoren

01:25:25.280 --> 01:25:27.120
laufen kann, aber

01:25:27.120 --> 01:25:29.120
den Fall, dass man jetzt Software hat, die

01:25:29.120 --> 01:25:30.840
tatsächlich auf vielen Prozessoren laufen muss

01:25:30.840 --> 01:25:33.320
den haben die meisten Programmierer

01:25:33.320 --> 01:25:35.280
gar nicht, ja, denn dieser Anwendungsfall

01:25:35.280 --> 01:25:36.860
trifft ja nur einen kleinen Teil

01:25:36.860 --> 01:25:38.100
Spieleprogrammierer

01:25:38.100 --> 01:25:40.700
Spieleprogrammierer und unter Umständen ja, Leute, die

01:25:40.700 --> 01:25:42.860
einen Datenbank-Server schreiben oder irgendwie einen Web-Server

01:25:42.860 --> 01:25:44.140
ja, einen Web-Server nicht mal

01:25:44.140 --> 01:25:47.880
oder ich weiß es gar nicht

01:25:47.880 --> 01:25:49.020
mir fällt es sogar tatsächlich schwer

01:25:49.020 --> 01:25:50.600
mir da

01:25:50.600 --> 01:25:53.300
Anwendungsfälle zu bauen, die das

01:25:53.300 --> 01:25:54.440
irgendwie erfordern

01:25:54.440 --> 01:25:57.240
insofern ist halt diese Beschränkung

01:25:57.240 --> 01:25:58.480
ist halt nicht so schlimm, wie sie aussieht

01:25:58.480 --> 01:26:00.980
und in Java, das sieht total toll aus

01:26:00.980 --> 01:26:03.240
auf dem Papier, irgendwie kann auf vielen Prozessoren

01:26:03.240 --> 01:26:03.680
laufen

01:26:03.680 --> 01:26:07.060
in der Praxis ist es aber blöd, das Single Thread Performance

01:26:07.060 --> 01:26:08.700
ist nicht gut und

01:26:08.700 --> 01:26:11.040
also das, was halt die meisten Leute interessiert, wenn sie

01:26:11.040 --> 01:26:13.000
jetzt irgendwie irgendwas starten, ein Programm starten

01:26:13.000 --> 01:26:14.380
und das tut dann irgendwas, dann ist es halt

01:26:14.380 --> 01:26:17.200
das ist halt langsamer, ja, das ist halt

01:26:17.200 --> 01:26:19.060
genau der Grund, warum, wenn ich jetzt in so einer

01:26:19.060 --> 01:26:20.880
IntelliJ IDE auf den Kopf drücke

01:26:20.880 --> 01:26:23.100
dann, dass es halt irgendwie sich alles so zäh anfühlt, weil

01:26:23.100 --> 01:26:24.480
ja, Single Thread Performance ist nicht so toll

01:26:24.480 --> 01:26:25.440
und

01:26:25.440 --> 01:26:29.200
das ist, und Latenz

01:26:29.200 --> 01:26:31.000
nicht vorhersagbar, klingt nicht so schlimm, ist

01:26:31.000 --> 01:26:32.460
aber in der Praxis doof, weil manchmal

01:26:32.460 --> 01:26:33.160
äh

01:26:33.160 --> 01:26:36.140
zur falschen Zeit irgendwie, wenn was

01:26:36.140 --> 01:26:38.940
mehr Latenz braucht, kann halt sein, dass es halt unter Umständen sehr teuer wird

01:26:38.940 --> 01:26:41.000
äh, je nachdem, was man

01:26:41.000 --> 01:26:42.460
da für Services betreibt und

01:26:42.460 --> 01:26:44.580
ja, das sind eigentlich

01:26:44.580 --> 01:26:47.020
das sind Dinge, die hören sich harmlos an, sind aber ziemlich schlimm

01:26:47.020 --> 01:26:49.080
während in Python, das hört sich ziemlich schlimm an

01:26:49.080 --> 01:26:50.300
ist aber gar nicht so furchtbar

01:26:50.300 --> 01:26:53.020
und wenn man dann tatsächlich so eins von diesen Problemen hat, dann kann man halt

01:26:53.020 --> 01:26:54.820
da drum herum arbeiten, oft, indem man

01:26:54.820 --> 01:26:56.080
dann halt viele Prozesse startet

01:26:56.080 --> 01:26:58.840
gut, dann muss man irgendwie dazwischen

01:26:58.840 --> 01:27:00.960
kommunizieren, muss irgendwie vielleicht Chat Memory haben

01:27:00.960 --> 01:27:02.080
oder solche Sachen, aber

01:27:02.080 --> 01:27:03.080
aber

01:27:03.080 --> 01:27:03.800
es geht

01:27:03.800 --> 01:27:06.700
selbst wenn man jetzt in einer Sprache ist, wo es theoretisch möglich ist

01:27:06.700 --> 01:27:08.680
das alles in einem Prozess zu machen, ist es auch oft

01:27:08.680 --> 01:27:10.440
nicht so eine gute Idee, weil

01:27:10.440 --> 01:27:12.720
äh, das dann oft sehr kompliziert

01:27:12.720 --> 01:27:14.720
wird, äh, und man halt auch

01:27:14.720 --> 01:27:16.380
ordentlich locken muss und

01:27:16.380 --> 01:27:18.660
ja, wirklich sich

01:27:18.660 --> 01:27:20.460
vorzustellen, was passiert, äh, wenn

01:27:20.460 --> 01:27:22.700
ein Prozess auf mehreren CPU

01:27:22.700 --> 01:27:24.560
parallel unterschiedliche Dinge tut

01:27:24.560 --> 01:27:26.060
äh

01:27:26.060 --> 01:27:28.220
das ist, das ist einfach für auch

01:27:28.220 --> 01:27:30.780
die allermeisten Programmierer überfordert das total

01:27:30.780 --> 01:27:32.200
also mich überfordert das total, also

01:27:32.200 --> 01:27:33.000
äh,

01:27:33.000 --> 01:27:34.860
du kannst nicht einfach multidimensionale Matrizen

01:27:34.860 --> 01:27:35.960
in deinem Kopf schungieren, also

01:27:35.960 --> 01:27:37.860
ja, also, ähm, das ist

01:27:37.860 --> 01:27:39.920
so, und wenn man jetzt sozusagen

01:27:39.920 --> 01:27:42.960
etwas, was zu schwierig für die meisten Leute ist

01:27:42.960 --> 01:27:44.940
und selten gebraucht wird, halt, äh

01:27:44.940 --> 01:27:46.940
sagt, das ist etwas, auf das optimieren

01:27:46.940 --> 01:27:48.240
wir hin, dann ist das irgendwie einfach

01:27:48.240 --> 01:27:50.440
naja, ich weiß nicht, ob das so sinnvoll ist, aber

01:27:50.440 --> 01:27:52.740
ja. Wenn ihr anderer Meinung seid,

01:27:52.740 --> 01:27:54.320
schreibt eine E-Mail, ne, an handels-

01:27:54.320 --> 01:27:55.580
handels-podcast.de

01:27:55.580 --> 01:27:58.540
Ja, also, ich meine, das ist jetzt nicht die

01:27:58.540 --> 01:28:00.780
reine Wahrheit, sozusagen

01:28:00.780 --> 01:28:02.340
sondern es ist natürlich sehr gefärbt

01:28:02.340 --> 01:28:03.620
äh, ich mag halt Python, aber

01:28:03.620 --> 01:28:04.940
ja

01:28:04.940 --> 01:28:08.040
ich finde, die haben da einfach einen sehr schönen

01:28:08.040 --> 01:28:10.380
Sweet-Spot, äh, quasi

01:28:10.380 --> 01:28:12.660
Klingt, als ist das eine Sprache,

01:28:12.660 --> 01:28:14.320
die auch zukunftsträchtig durchaus ist, ja

01:28:14.320 --> 01:28:16.080
Achso, hatten wir das, hatten wir eigentlich das

01:28:16.080 --> 01:28:17.900
äh, Send auf Python schon?

01:28:17.900 --> 01:28:19.820
Nein, das haben wir noch nicht, äh, gemacht

01:28:19.820 --> 01:28:22.120
das wäre jetzt tatsächlich am Ende der Mythen noch der Punkt

01:28:22.120 --> 01:28:24.140
Vielleicht sollten wir das nochmal kurz, äh, äh

01:28:24.140 --> 01:28:26.180
Send auf Python, das hört sich ja sehr philosophisch an, so ein bisschen

01:28:26.180 --> 01:28:28.020
nach, äh, fernöstlicher

01:28:28.020 --> 01:28:28.980
Philosophie

01:28:32.340 --> 01:28:34.540
Wir rufen es gerade auf und, äh, möchtest

01:28:34.540 --> 01:28:35.960
du es tatsächlich zitieren, oder?

01:28:35.960 --> 01:28:38.500
Ich, ich, ich denke schon, tatsächlich, also man kann sich das

01:28:38.500 --> 01:28:40.380
auch selber angucken, wenn man einfach so einen, so

01:28:40.380 --> 01:28:42.100
Python startet, also einfach Python eingibt

01:28:42.100 --> 01:28:44.340
und dann sagt import this, dann

01:28:44.340 --> 01:28:46.620
äh, äh, erscheint

01:28:46.620 --> 01:28:48.200
erscheint das und das, äh,

01:28:48.200 --> 01:28:50.060
bringt halt so ein bisschen zum Ausdruck, was so

01:28:50.060 --> 01:28:51.400
äh, Python

01:28:51.400 --> 01:28:54.400
besonders macht oder, äh, wie man Dinge

01:28:54.400 --> 01:28:56.440
in Python tut und wie sie vielleicht ein bisschen anders

01:28:56.440 --> 01:28:58.020
sind, als man das normalerweise vielleicht gewohnt ist

01:28:58.020 --> 01:29:00.140
und, äh,

01:29:00.140 --> 01:29:02.140
ähm, ja, da sind halt eben solche

01:29:02.140 --> 01:29:04.240
solche Dinge drin,

01:29:04.240 --> 01:29:06.120
ich weiß nicht, ne, stimmt, also die alle durchgehen, muss man

01:29:06.120 --> 01:29:06.920
vielleicht nicht, das ist halt

01:29:06.920 --> 01:29:10.040
Ja, das ist

01:29:10.040 --> 01:29:11.200
ja, kann man, kann man

01:29:11.200 --> 01:29:14.000
Ja, ich glaube, das steht auch am Anfang von, von der

01:29:14.000 --> 01:29:16.200
Pep, äh, Version, kann das

01:29:16.200 --> 01:29:18.080
auch sein, also von dem Style Guide, den es

01:29:18.080 --> 01:29:20.140
für Python auf der offiziellen

01:29:20.140 --> 01:29:21.340
Seite gibt? Ja

01:29:21.340 --> 01:29:24.060
Ich weiß nicht so genau, aber kann so, kann gut sein

01:29:24.060 --> 01:29:26.140
Ich, äh, ja, dann halt

01:29:26.140 --> 01:29:28.000
solche Sachen wie explizit ist besser als

01:29:28.000 --> 01:29:30.020
implizit, ja, das ist halt auch, so man, man

01:29:30.020 --> 01:29:31.940
merkt auch dem Ding an, dass es so ein bisschen sich halt

01:29:31.940 --> 01:29:33.860
in, in, in viele, viele Punkte, äh,

01:29:33.860 --> 01:29:35.880
sind so abgrenzend Richtung Pearl, glaube ich

01:29:35.880 --> 01:29:36.340
Ja

01:29:36.340 --> 01:29:39.300
Also, äh,

01:29:39.300 --> 01:29:40.920
ja, das, äh,

01:29:40.920 --> 01:29:43.700
einfach ist besser als komplex, ja, komplex

01:29:43.700 --> 01:29:44.740
ist besser als kompliziert

01:29:44.740 --> 01:29:47.740
Ja, äh, flach ist

01:29:47.740 --> 01:29:49.780
besser als, äh, verschachtelt

01:29:49.780 --> 01:29:51.420
Äh, ja,

01:29:51.420 --> 01:29:53.580
äh, ja, sparse, weil ich das gar nicht

01:29:53.580 --> 01:29:55.240
in diesem Kontext übersetzen soll, aber es ist halt

01:29:55.240 --> 01:29:58.100
sozusagen, ähm,

01:29:58.100 --> 01:29:59.600
ja, sparse ist better

01:29:59.600 --> 01:30:01.740
äh, than dense, äh,

01:30:01.740 --> 01:30:03.720
sozusagen, lieber übersichtlich

01:30:03.720 --> 01:30:05.340
als, äh, also nicht alles in eine Zeile packen

01:30:05.340 --> 01:30:07.820
Genau, genau, sozusagen, äh, ja

01:30:07.820 --> 01:30:09.380
Lesbarkeit zählt

01:30:09.380 --> 01:30:11.640
Also zwischendurch mal leerzeilen lassen, äh,

01:30:11.640 --> 01:30:12.920
höre die Lesbarkeit ungemein

01:30:12.920 --> 01:30:15.580
Ja, das ist überhaupt eines der Designziele bei Python gewesen, dass man

01:30:15.580 --> 01:30:17.140
das halt, äh, weil

01:30:17.140 --> 01:30:19.640
Code einfach viel öfter gelesen als geschrieben

01:30:19.640 --> 01:30:21.480
wird, das vielleicht Sinn macht, das

01:30:21.480 --> 01:30:23.020
darauf zu optimieren, dass man das gut lesen kann

01:30:23.020 --> 01:30:25.500
Also wenn euer Nachbar den ja abends aus dem Bett klingelt, dann noch lesen kann, was

01:30:25.500 --> 01:30:27.540
er da für ein Paar geschrieben hat, dann seid ihr vielleicht bei Python

01:30:27.540 --> 01:30:29.560
besser aufgehoben als bei anderen

01:30:29.560 --> 01:30:30.140
Sprachen, ja

01:30:30.140 --> 01:30:31.700
Ja, ähm,

01:30:31.740 --> 01:30:34.500
ähm, genau, ja, äh,

01:30:34.500 --> 01:30:36.000
Spezialfälle sind nicht

01:30:36.000 --> 01:30:38.000
speziell genug, um, äh, die Regeln

01:30:38.000 --> 01:30:39.900
zu brechen, aber

01:30:39.900 --> 01:30:42.060
Pragmatismus besser oder Practicality

01:30:42.060 --> 01:30:43.960
äh, ist besser als, als, als die reine

01:30:43.960 --> 01:30:44.640
Lehre als Purity

01:30:44.640 --> 01:30:46.580
Wie lange schreibst du deine Zeilen?

01:30:46.580 --> 01:30:49.780
Äh, ich hab das letztens

01:30:49.780 --> 01:30:51.160
erst geändert, glaube ich, auf

01:30:51.160 --> 01:30:53.260
130, ich glaube, ich glaube,

01:30:53.260 --> 01:30:55.940
79, 130, 150, irgendwie so

01:30:55.940 --> 01:30:57.780
Ja, ja, ich hatte das ganz lange, also bis vor kurzem

01:30:57.780 --> 01:30:59.340
hab ich tatsächlich auch, äh, 79

01:30:59.340 --> 01:31:01.520
verwendet. Also das für die Leute, die

01:31:01.520 --> 01:31:03.420
alte Monitore verwenden, die konnten auch nicht mehr lesen

01:31:03.420 --> 01:31:05.540
oder die halt gescherte Terminals verwenden mit mehreren Seiten

01:31:05.540 --> 01:31:07.780
Ja, Terminals sind vor allen Dingen, genau

01:31:07.780 --> 01:31:09.640
äh, ja, äh, dann

01:31:09.640 --> 01:31:11.500
ist halt bei 80 Zeichen

01:31:11.500 --> 01:31:13.480
Schluss und, äh, genau

01:31:13.480 --> 01:31:15.380
das wäre natürlich, deswegen hab ich das auch ganz lange gemacht

01:31:15.380 --> 01:31:17.600
aber tatsächlich ist es so, dass heutzutage

01:31:17.600 --> 01:31:19.420
hat man diese Anwendungsfälle

01:31:19.420 --> 01:31:21.400
fast nicht mehr und, äh

01:31:21.400 --> 01:31:23.340
die Monitore kann man meistens besser

01:31:23.340 --> 01:31:25.560
coden, oder? Also es sieht besser aus auf einem eigenen

01:31:25.560 --> 01:31:27.420
Monitor, oder? Ja, es ist

01:31:27.420 --> 01:31:29.420
vor allen Dingen auch, äh, es gibt halt viele Fälle, wo es

01:31:29.420 --> 01:31:31.380
halt schwierig wird, wenn man dann immer quasi nach

01:31:31.380 --> 01:31:33.200
der, nach der Anzahl Zeilen umbrechen

01:31:33.200 --> 01:31:35.180
äh, Zeichen umbrechen muss

01:31:35.180 --> 01:31:37.120
dann muss man halt komisch rumformatieren

01:31:37.120 --> 01:31:39.160
äh, und dann lieber

01:31:39.160 --> 01:31:41.300
schön, und dann lieber schön, ja, und das

01:31:41.300 --> 01:31:42.820
bricht halt dann diese, diese Begrenzung

01:31:42.820 --> 01:31:45.120
so gerade bei Tests, finde ich, ist es sehr schwer, das

01:31:45.120 --> 01:31:47.020
einzuhalten, weil oft muss man halt lange

01:31:47.020 --> 01:31:49.300
Testnamen haben

01:31:49.300 --> 01:31:51.340
oder, wenn das irgendwie sprechend sein soll

01:31:51.340 --> 01:31:53.100
und gut lesbar sein soll, dann, äh

01:31:53.100 --> 01:31:55.260
im gleichen Namen noch umgebrochen, uh, ja

01:31:55.260 --> 01:31:57.300
ja, genau, dann kann, kann man eigentlich

01:31:57.300 --> 01:31:59.100
nicht mehr umbrechen und dann wird's halt einfach lang

01:31:59.100 --> 01:32:01.240
also, daher bin ich jetzt, ich, ich

01:32:01.240 --> 01:32:02.920
weiß nicht, ich glaub, 130, äh, ich weiß nicht

01:32:02.920 --> 01:32:05.020
noch, wie die, wie die konkrete Zahl ist

01:32:05.020 --> 01:32:07.180
äh, vielleicht rede ich auch Unsinn, ich benutze das halt

01:32:07.180 --> 01:32:09.060
ich formatiere meinen Code auch mit Black, also

01:32:09.060 --> 01:32:10.460
ich nehme das, was Black sagt

01:32:10.460 --> 01:32:12.880
und kümmere mich nicht mehr drum, ich hoffe, die haben das

01:32:12.880 --> 01:32:14.920
irgendwie gut überlegt und, ja

01:32:14.920 --> 01:32:16.280
ähm

01:32:16.280 --> 01:32:18.980
genau, was haben wir noch, äh

01:32:18.980 --> 01:32:21.140
ja, genau, Fehler sollten nicht einfach

01:32:21.140 --> 01:32:23.220
so, äh, still, äh

01:32:23.220 --> 01:32:25.180
weggeworfen werden, sondern sollten immer

01:32:25.180 --> 01:32:27.020
sichtbar sein. Also wir haben ja auch

01:32:27.020 --> 01:32:28.840
ein Python Assertion oder sowas, ich weiß nicht, ist das

01:32:28.840 --> 01:32:31.100
ein besonderes Feature oder gibt's das bei Ansprachen auch

01:32:31.100 --> 01:32:32.960
alles? Assert, das ist ein, ja, das ist

01:32:32.960 --> 01:32:35.360
ein, also, gut, das ist ein Keyword der Sprache, das, äh

01:32:35.360 --> 01:32:37.300
mit dem man halt, äh, überprüfen

01:32:37.300 --> 01:32:38.980
kann, ob irgendeine Bedingung oder

01:32:38.980 --> 01:32:41.040
irgendwas wahr ist, was sein soll, und wenn's halt

01:32:41.040 --> 01:32:43.160
nicht so ist, dann, äh, wirft

01:32:43.160 --> 01:32:44.560
das halt einen Fehler, ja

01:32:44.560 --> 01:32:47.140
kann man, kann man einen guten Test schreiben

01:32:47.140 --> 01:32:48.860
ja

01:32:48.860 --> 01:32:50.980
äh

01:32:50.980 --> 01:32:52.920
genau, ja

01:32:52.920 --> 01:32:55.100
Fehler sollten irgendwie nie still weggeworfen

01:32:55.100 --> 01:32:57.180
werden, außer man bringt sie zum Schweigen

01:32:57.180 --> 01:32:58.100
irgendwie explizit

01:32:58.100 --> 01:33:00.960
äh, ja, wenn man, wenn

01:33:00.960 --> 01:33:03.120
man irgendwie, äh, mehrere Dinge zur Auswahl

01:33:03.120 --> 01:33:05.260
hat, ja, äh

01:33:05.260 --> 01:33:06.840
sollte man irgendwie der Versuchung

01:33:06.840 --> 01:33:08.440
widerstehen, irgendwie einfach zu raten

01:33:08.440 --> 01:33:11.580
äh, es sollte nur ein und, äh

01:33:11.580 --> 01:33:12.960
möglichst nur

01:33:12.960 --> 01:33:14.980
einen, einen einzigen, äh

01:33:14.980 --> 01:33:16.900
äh, offensichtlichen Weg geben

01:33:16.900 --> 01:33:18.840
wie man Dinge, äh, tun, äh

01:33:18.840 --> 01:33:20.800
tun sollte, und das ist natürlich ganz, ganz klar

01:33:20.800 --> 01:33:22.760
irgendwie ein Ding gegen Perl, weil Perl ist halt

01:33:22.760 --> 01:33:24.600
das Gegenteil davon, es gibt irgendwie

01:33:24.600 --> 01:33:26.420
Perl ist auch, ich weiß nicht, da gibt's auch einen, einen

01:33:26.420 --> 01:33:27.940
ja, du kannst es halt irgendwie

01:33:27.940 --> 01:33:30.820
so machen, es gibt viele Wege zum

01:33:30.820 --> 01:33:32.460
Ziel, ne, du kannst es halt so machen, wie es dir am besten

01:33:32.460 --> 01:33:34.360
gefällt, was halt dann in der Praxis dummerweise

01:33:34.360 --> 01:33:36.480
dazu führt, dass es jeder irgendwie anders macht, und

01:33:36.480 --> 01:33:38.440
äh, das, äh, die Lesbarkeit

01:33:38.440 --> 01:33:40.500
natürlich extrem, weil, weil jeder schreibt

01:33:40.500 --> 01:33:42.220
dann halt sozusagen sein, sein Perl-Idiom

01:33:42.220 --> 01:33:44.500
und, ähm, man kann halt nicht mehr

01:33:44.500 --> 01:33:46.520
so gut, also bei, bei manchen Leuten war es

01:33:46.520 --> 01:33:48.320
so, wenn man das nicht angeguckt hat, dann

01:33:48.320 --> 01:33:50.020
äh, äh

01:33:50.020 --> 01:33:52.140
was, was, was ist das überhaupt, es gibt

01:33:52.140 --> 01:33:54.380
ich meine, teilweise ist es sehr schön, ich hab auch mal

01:33:54.380 --> 01:33:56.280
ich hab das mal, äh, äh

01:33:56.280 --> 01:33:58.340
ein Buch gelesen von, von, äh

01:33:58.340 --> 01:34:00.680
äh, Damien Conway, ich weiß nicht genau, Higher Order

01:34:00.680 --> 01:34:02.640
Perl oder sowas, äh, auch ganz

01:34:02.640 --> 01:34:04.560
viele verrückte Sachen gemacht, also was hab ich denn mit Begeisterung

01:34:04.560 --> 01:34:06.600
verwendet, und fand das total toll, was man alles

01:34:06.600 --> 01:34:08.680
für komplexe Geschichten irgendwie da in wenig

01:34:08.680 --> 01:34:10.400
äh, Zeichen irgendwie unterbringen kann

01:34:10.400 --> 01:34:12.760
aber ich glaub, äh, ich würd das heute

01:34:12.760 --> 01:34:14.720
wahrscheinlich nicht mehr lesen können, und meine Kollegen damals

01:34:14.720 --> 01:34:16.720
oder kurz danach konnten das wahrscheinlich auch nicht mehr

01:34:16.720 --> 01:34:18.660
lesen. Oder du selber, ich weiß nicht, zwei Stunden

01:34:18.660 --> 01:34:20.460
später. Ja, ja, zwei Stunden später ist halt dann vorbei

01:34:20.460 --> 01:34:22.580
und das ist, das ist nicht ganz so, es ist nicht

01:34:22.580 --> 01:34:24.500
optimal, das ist irgendwie, da ist, da kann man noch was

01:34:24.500 --> 01:34:26.580
verbessern. Zu lange danach gearbeitet, dann steht man morgens wieder

01:34:26.580 --> 01:34:28.820
auf und dann so, oh, was hab ich jetzt mal da gemacht, ähm

01:34:28.820 --> 01:34:30.540
äh, ähm

01:34:30.540 --> 01:34:32.820
ja, also, das, äh

01:34:32.820 --> 01:34:34.340
ähm, ja, heutzutage

01:34:34.340 --> 01:34:36.560
Also dokumentiert immer schön euren Code, in Python könnt ihr

01:34:36.560 --> 01:34:38.640
damit sogar Doctests machen, ne, das heißt, ihr testet

01:34:38.640 --> 01:34:40.120
dann selber auch das, was ihr dokumentiert

01:34:40.120 --> 01:34:42.620
Ja, weiß ich aber nicht, ob das so ein schlauer, also

01:34:42.620 --> 01:34:44.480
ob das so eine gute Idee ist, kann man machen

01:34:44.480 --> 01:34:46.660
Nein, macht man nicht. Ja, ich

01:34:46.660 --> 01:34:48.480
würde eher explizite Tests

01:34:48.480 --> 01:34:50.520
schreiben, so, und ich würde auch PyTest nehmen

01:34:50.520 --> 01:34:51.640
es gibt halt auch das eingebaute

01:34:51.640 --> 01:34:54.300
Test-Framework, äh, von, von

01:34:54.300 --> 01:34:56.260
Python, das sich stark an

01:34:56.260 --> 01:34:58.000
äh, JUnit, äh, glaub ich

01:34:58.000 --> 01:35:00.400
einem Unit-Testing von, von Java irgendwie orientiert

01:35:00.400 --> 01:35:01.620
hat, äh, ich weiß gar nicht, wie das heißt

01:35:01.620 --> 01:35:04.140
und, äh,

01:35:04.140 --> 01:35:05.860
das ist komisch, weil es ist halt nicht so richtig

01:35:05.860 --> 01:35:07.460
Pythonisch, weil

01:35:07.460 --> 01:35:10.240
es ist halt halt so, die Dinge wie, äh,

01:35:10.240 --> 01:35:12.340
Konventionen, per Konvention sind

01:35:12.340 --> 01:35:14.580
halt die Methodennamen CamelCase

01:35:14.580 --> 01:35:16.060
und nicht mit Underscore, normalerweise

01:35:16.060 --> 01:35:18.360
Underscore, und da ist aber CamelCase

01:35:18.360 --> 01:35:20.220
so wie in Java, und das ist halt, sieht

01:35:20.220 --> 01:35:22.120
komisch aus, äh,

01:35:22.120 --> 01:35:24.500
und diverse andere Dinge sind auch eigenartig

01:35:24.500 --> 01:35:26.260
das fühlt sich oft eher an, als würde man

01:35:26.260 --> 01:35:28.380
Java schreiben als Python, und das ist halt eigentlich nicht schön

01:35:28.380 --> 01:35:30.260
und deswegen würde ich eben nicht das

01:35:30.260 --> 01:35:32.540
eingebaute Ding nehmen, nicht das eingebaute Unit-Test-Framework

01:35:32.540 --> 01:35:34.320
sondern, wobei, wobei von den Features her

01:35:34.320 --> 01:35:35.700
die können quasi das gleiche

01:35:35.700 --> 01:35:37.860
Aber die Dock-Tests ist ja jetzt nicht, äh, oder, oder?

01:35:37.860 --> 01:35:39.300
Dock-Tests weiß ich gar nicht

01:35:39.300 --> 01:35:42.160
Weil die Dock-Tests ja einfach in den Dokumentationen dann irgendwie die Funktionen testen

01:35:42.160 --> 01:35:44.180
Ich, ich weiß, äh, weiß gar nicht

01:35:44.180 --> 01:35:46.220
ob das, ähm

01:35:46.220 --> 01:35:50.100
wie die ausgeführt werden, oder welche Testrunner

01:35:50.100 --> 01:35:51.960
die dann halt, äh, äh, ausführt

01:35:51.960 --> 01:35:54.080
Wenn das, wenn man den einstellen kann oder so, das kann

01:35:54.080 --> 01:35:56.140
auch alles gut, aber

01:35:56.140 --> 01:35:58.400
äh, ich, ich würde halt

01:35:58.400 --> 01:36:00.120
eher als Testrunner eigentlich immer eher PyTest verwenden

01:36:00.120 --> 01:36:02.080
Ja, ja, ich glaube PyTest

01:36:02.080 --> 01:36:03.440
nimmt auch die Dock-Tester mit an, oder so

01:36:03.440 --> 01:36:05.800
Das, das kann gut sein, das, ich hab das, ich hab noch nie

01:36:05.800 --> 01:36:07.860
Dock-Test, äh, aber das ist auch alles nur geraten, ähm

01:36:07.860 --> 01:36:09.700
Keine Ahnung, muss man sich mal, muss man sich mal angucken

01:36:09.700 --> 01:36:10.420
Vielleicht ist auch alles gut

01:36:10.420 --> 01:36:13.900
Aber ich würde auf jeden Fall, wenn man, das ist halt auch so

01:36:13.900 --> 01:36:16.040
eine unoffensichtliche Geschichte, ne, wenn man vielleicht anfängt

01:36:16.040 --> 01:36:18.380
dann denkt man sich so, ach, ich nehme jetzt das eingebaute Unit-Test

01:36:18.380 --> 01:36:19.720
Framework

01:36:19.720 --> 01:36:22.040
Implementation ist hard to explain

01:36:22.040 --> 01:36:23.460
It's a bad idea, deswegen

01:36:23.460 --> 01:36:25.280
send off, also, ihr seht schon

01:36:25.280 --> 01:36:27.780
Wenn wir jetzt irgendwie anfangen rumzustammeln, dann ist das alles

01:36:27.780 --> 01:36:29.980
totale Grütze, was sie da gebaut haben, natürlich, ähm

01:36:29.980 --> 01:36:31.140
Äh, ja

01:36:31.140 --> 01:36:34.080
Ja, now is better than

01:36:34.080 --> 01:36:35.100
never, ja

01:36:35.100 --> 01:36:37.880
Ja, also das Do-It, ne, so ein bisschen das Nike-Prinzip

01:36:37.880 --> 01:36:39.860
Also einfach anfangen, machen, Prototyping

01:36:39.860 --> 01:36:42.240
Ob schon

01:36:42.240 --> 01:36:43.820
Niemals

01:36:43.820 --> 01:36:45.700
Vielleicht, äh, oft besser

01:36:45.700 --> 01:36:47.420
sein könnte als genau jetzt

01:36:47.420 --> 01:36:50.060
Ja, man weiß

01:36:50.060 --> 01:36:50.720
Wenn man das so genau

01:36:50.720 --> 01:36:54.140
Wenn die Implementation schlecht zu erklären ist

01:36:54.140 --> 01:36:55.680
Äh, es ist eine schlechte Idee

01:36:55.680 --> 01:36:57.920
Wenn die Implementation leicht zu erklären

01:36:57.920 --> 01:36:59.840
ist, könnte es sein, das ist eine gute Idee

01:36:59.840 --> 01:37:00.640
Ist, aber

01:37:00.640 --> 01:37:01.840
Ja

01:37:01.840 --> 01:37:05.180
Ja, Namespace ist eine total tolle Idee

01:37:05.180 --> 01:37:07.440
Sollte man irgendwie mehr von machen, ja

01:37:07.440 --> 01:37:08.360
Ja, das ist

01:37:08.360 --> 01:37:10.380
Was ist das an Namespace? Vielleicht musst du das nochmal kurz sagen

01:37:10.380 --> 01:37:12.480
Ähm

01:37:12.480 --> 01:37:16.260
Sozusagen

01:37:16.260 --> 01:37:18.240
ein, ein, ein, ja, wie kann man das generell

01:37:18.240 --> 01:37:18.820
Also, äh

01:37:18.820 --> 01:37:22.320
Korrekt übersetzen wir ja, der Namentraum, also wenn man

01:37:22.320 --> 01:37:24.400
sein, äh, Variable genauso

01:37:24.400 --> 01:37:26.260
nennt wie die Nachbarvariable, dann ist es relativ

01:37:26.260 --> 01:37:28.080
schwierig, die dann irgendwann auseinander zu halten, weil

01:37:28.080 --> 01:37:29.800
wenn man das eine Kind rufkommt, entweder beide oder

01:37:29.800 --> 01:37:31.640
nur eins von beiden, oder gar nichts mehr, oder

01:37:31.640 --> 01:37:33.740
Und dann kann man das mit einem Namensraum-Präfixen

01:37:33.740 --> 01:37:35.760
sozusagen, in dem dann halt ein Name eindeutig ist

01:37:35.760 --> 01:37:37.580
Was so ein bisschen, ich weiß nicht, ob da ist

01:37:37.580 --> 01:37:39.280
eine leichte Ironie, fürchte ich, drin, weil

01:37:39.280 --> 01:37:41.460
bei beiden ist das halt nicht so schön getrennt, und wenn man jetzt

01:37:41.460 --> 01:37:43.500
zum Beispiel vom irgendein

01:37:43.500 --> 01:37:45.600
Modul-Importstern sagt, dann

01:37:45.600 --> 01:37:47.180
überschreibt einem das gnadenlos halt

01:37:47.180 --> 01:37:49.560
irgendwie Dinge, die man

01:37:49.560 --> 01:37:51.600
selber definiert hat vielleicht, oder aus

01:37:51.600 --> 01:37:53.200
anderen Modulen oder so, die halt in dem

01:37:53.200 --> 01:37:55.640
Man kann auch übrigens die ganze Standardbibliothek überschreiben, wenn man

01:37:55.640 --> 01:37:57.400
einfach viel Namen verwendet. Ja, ja, kann man

01:37:57.400 --> 01:37:59.640
alles machen, es gibt auch Leute, die dann, um das zu

01:37:59.640 --> 01:38:01.620
gehen, sagen, die dann irgendwie import dieses

01:38:01.620 --> 01:38:02.460
vom das

01:38:02.460 --> 01:38:05.220
als irgendwie was ganz anderes,

01:38:05.220 --> 01:38:07.580
damit sie auf keinen Fall irgendwie sich Dinge

01:38:07.580 --> 01:38:08.380
überschreiben und so

01:38:08.380 --> 01:38:11.280
Ja, das ist alles so ein bisschen

01:38:11.280 --> 01:38:13.240
Aber

01:38:13.240 --> 01:38:15.600
im Grunde gibt es natürlich schon

01:38:15.600 --> 01:38:17.700
Namensräume in Python, und

01:38:17.700 --> 01:38:19.600
ja, das funktioniert

01:38:19.600 --> 01:38:21.540
eigentlich auch ganz gut

01:38:21.540 --> 01:38:23.540
Ja

01:38:23.540 --> 01:38:27.700
Wir sehen, auf Python

01:38:27.700 --> 01:38:29.560
haben wir jetzt schon ein bisschen den Zuhörern

01:38:29.560 --> 01:38:31.280
auch noch nähergebracht, also was man darunter so ein bisschen

01:38:31.280 --> 01:38:33.360
versteht, wie man, ich sag mal, ganz

01:38:33.360 --> 01:38:35.320
besonders entspannenden Python-Code

01:38:35.320 --> 01:38:37.420
schreiben, wie man da richtig rangeht, also

01:38:37.420 --> 01:38:39.260
tatsächlich müsst ihr es nicht zu komplex machen, ich glaube, wenn man

01:38:39.260 --> 01:38:41.380
die einfache Lösung ist besser, keep it

01:38:41.380 --> 01:38:43.460
short and simple, das ist

01:38:43.460 --> 01:38:45.300
glaube ich immer eine gute Idee, auch

01:38:45.300 --> 01:38:46.580
unabhängig vom Python, aber

01:38:46.580 --> 01:38:49.140
dadurch wird es halt sehr lesbar und sehr

01:38:49.140 --> 01:38:51.520
korrigierbar, ihr könnt auch sehr gut damit kooperativ

01:38:51.520 --> 01:38:53.080
arbeiten mit anderen, weil ihr, glaube ich, relativ

01:38:53.080 --> 01:38:55.360
schnell verstehen werdet, was sie da denn so getan

01:38:55.360 --> 01:38:57.080
haben, ich meine, auch da gibt es Ausnahmen, aber

01:38:57.080 --> 01:38:59.080
das kann auch sein, dass das die

01:38:59.080 --> 01:38:59.400
äh

01:38:59.400 --> 01:39:03.080
ich weiß nicht, ob es immer gut ist, wenn man schnell versteht, was andere da getan haben

01:39:03.080 --> 01:39:05.160
das könnte auch so, äh

01:39:05.160 --> 01:39:05.400
ja

01:39:05.400 --> 01:39:08.800
wie das bei Douglas Adams oder so

01:39:08.800 --> 01:39:11.260
irgendwie, als der Babelfisch eingeführt wurde

01:39:11.260 --> 01:39:13.240
und alle sich plötzlich verstanden haben, dass es gab den

01:39:13.240 --> 01:39:14.980
schlimmsten Krieg ever, oder

01:39:14.980 --> 01:39:15.980
keine Ahnung, irgendwie so

01:39:15.980 --> 01:39:18.780
Ja, das ist immer jetzt hier, das ist ein paar lustige Sachen, die ich letztens gesehen habe

01:39:18.780 --> 01:39:21.600
irgendwie mit Lesen von Gesichtsmuskulatur

01:39:21.600 --> 01:39:23.140
und sowas, dann die Worte deines

01:39:23.140 --> 01:39:25.260
inneren Gedankens aufschreiben kann und so, das ist

01:39:25.260 --> 01:39:25.560
ja

01:39:25.560 --> 01:39:27.520
Naja

01:39:27.520 --> 01:39:29.240
Ja

01:39:29.240 --> 01:39:32.180
Alter Ego heißt das Ding

01:39:32.180 --> 01:39:34.980
Ach, okay, ja, da wird auch noch eine Menge

01:39:34.980 --> 01:39:37.120
interessante, werden noch eine Menge interessante

01:39:37.120 --> 01:39:37.960
Dinge passieren, glaube ich

01:39:37.960 --> 01:39:41.020
Ja, aber ansonsten, ich weiß nicht genau, sind wir

01:39:41.020 --> 01:39:42.620
so ein bisschen durch, ne, mit der Einführung

01:39:42.620 --> 01:39:45.040
Ja, ich würde das tatsächlich sagen, wir sind langsam am Ende der ersten

01:39:45.040 --> 01:39:46.400
Folge angekommen, also wir haben es

01:39:46.400 --> 01:39:48.960
quasi fast geschafft, also was haben wir jetzt gerade schon gemacht

01:39:48.960 --> 01:39:50.960
wir haben uns dann auf Python kennengelernt, haben uns

01:39:50.960 --> 01:39:52.560
ein bisschen an die Einführungstools gegeben

01:39:52.560 --> 01:39:54.740
so ein bisschen die Features der Sprache uns

01:39:54.740 --> 01:39:56.360
angeschaut, irgendwie

01:39:56.360 --> 01:39:59.100
Ja, ja, wie kann man einen Einstieg

01:39:59.100 --> 01:40:00.800
finden, wofür wird das eingesetzt

01:40:00.800 --> 01:40:02.980
Also falls ihr Fragen habt, wie gesagt

01:40:02.980 --> 01:40:04.780
schreibt uns gerne an unsere E-Mail-Adresse

01:40:04.780 --> 01:40:06.880
da kriegt ihr alles nochmal

01:40:06.880 --> 01:40:08.800
erklärt, ihr filmt mit Sicherheit auch ganz viel im Internet

01:40:08.800 --> 01:40:10.960
in Tutorials, es gibt ja unzählige

01:40:10.960 --> 01:40:12.640
schöne, spannende Seiten

01:40:12.640 --> 01:40:14.920
die Suchbegriffe werdet ihr bestimmt schon finden dafür

01:40:14.920 --> 01:40:17.160
Ja, genau, dann

01:40:17.160 --> 01:40:19.020
würde ich sagen, in den

01:40:19.020 --> 01:40:20.720
nächsten Episoden gehen wir dann halt mal so

01:40:20.720 --> 01:40:22.860
oder da machen wir halt so irgendwie ein Thema

01:40:22.860 --> 01:40:24.860
pro Episode und gucken einfach mal, dass wir

01:40:24.860 --> 01:40:27.080
das ein bisschen näher beleuchten. Genau, nicht so der ganz allgemeine

01:40:27.080 --> 01:40:28.960
Schwank, sondern vielleicht tatsächlich irgendwie

01:40:28.960 --> 01:40:30.760
was Spezielles, irgendwie eine Modul-Juridik

01:40:30.760 --> 01:40:32.380
oder eine Technik oder

01:40:32.380 --> 01:40:34.500
irgendwie eins der Topics, die noch spannend sind

01:40:34.500 --> 01:40:36.860
Wenn ihr Vorschläge habt, wenn ihr irgendwas Besonderes hören wollt

01:40:36.860 --> 01:40:38.620
kommt gerne, sagt da von Voss

01:40:38.620 --> 01:40:40.840
der, ja, Jochen wird euch bestimmt

01:40:40.840 --> 01:40:42.120
was dazu erzählen können

01:40:42.120 --> 01:40:44.920
und ich stelle Ihnen blöde Fragen, also so ist das

01:40:44.920 --> 01:40:46.840
Ja, und vielleicht beschließen wir noch

01:40:46.840 --> 01:40:48.420
ein bisschen mit Veranstaltungshinweisen, wir sind ja hier

01:40:48.420 --> 01:40:50.680
Wir sind ja jetzt in Düsseldorf, also

01:40:50.680 --> 01:40:52.580
wenn ihr selber Veranstaltungshinweise habt

01:40:52.580 --> 01:40:54.960
dann sagt doch bitte gerne Bescheid

01:40:54.960 --> 01:40:56.600
dann können wir auch eure Veranstaltungen jetzt im

01:40:56.600 --> 01:40:58.820
deutschsprachigen Raum gerne promoten und hier vorstehen

01:40:58.820 --> 01:41:00.420
Bei uns ist nächste Woche

01:41:00.420 --> 01:41:02.400
nächstes Wochenende jetzt hier Python Sprint

01:41:02.400 --> 01:41:04.680
Das ist immer eine tolle Gelegenheit, so ein bisschen

01:41:04.680 --> 01:41:06.320
Leute kennenzulernen, ich glaube, der ist diesmal schon voll

01:41:06.320 --> 01:41:08.820
und auch die Wartezeit ist schon voll, aber er ist glaube ich zweimal im Jahr

01:41:08.820 --> 01:41:10.060
gibt es bei Meetup oder

01:41:10.060 --> 01:41:12.460
bei PyDDF, also die Düsseldorfer

01:41:12.460 --> 01:41:14.600
PyDDF.de, super tolle Leute, immer ganz

01:41:14.600 --> 01:41:16.080
viele entspannende Vorträge

01:41:16.080 --> 01:41:18.160
Schaut euch das auch einfach mal an und

01:41:18.160 --> 01:41:20.700
ja, tatsächlich

01:41:20.700 --> 01:41:22.660
zweimal im Jahr, also schaut einfach

01:41:22.660 --> 01:41:24.640
mal vorbei. Ja, also wenn ihr

01:41:24.640 --> 01:41:26.680
die Events in eurer Nähe promotet, schickt ihr auch

01:41:26.680 --> 01:41:28.680
eine E-Mail einfach an hallo.pythonpodcast.de

01:41:28.680 --> 01:41:29.560
Ja

01:41:29.560 --> 01:41:32.640
Ansonsten, genau, was faszinierend ist, es gibt einmal

01:41:32.640 --> 01:41:33.580
die Python User Group

01:41:33.580 --> 01:41:36.340
Düsseldorf, PyDDF, die halt auch diese

01:41:36.340 --> 01:41:38.500
Sprints organisiert. Es gibt

01:41:38.500 --> 01:41:40.500
einen Python-Foo, das ist

01:41:40.500 --> 01:41:42.560
im lokalen Düsseldorf

01:41:42.560 --> 01:41:44.500
Microspace in Chaosdorf, das ist einmal

01:41:44.500 --> 01:41:45.620
wöchentlich, ist deutlich kleiner

01:41:45.620 --> 01:41:48.860
Es sind mehr so

01:41:48.860 --> 01:41:50.820
immer die gleichen Leute, die da hingehen

01:41:50.820 --> 01:41:52.820
Die ersten zwei Mal im Monat ist glaube ich

01:41:52.820 --> 01:41:54.540
für Anfänger und die letzten zwei Mal ist

01:41:54.540 --> 01:41:54.920
Ja

01:41:54.920 --> 01:41:58.140
Aber ich finde, es ist auch ganz toll,

01:41:58.540 --> 01:41:59.340
irgendwie sollte man

01:41:59.340 --> 01:42:02.320
sich nicht von abschränken lassen,

01:42:02.320 --> 01:42:03.940
das ist halt so ein bisschen, dass man so reinkommt und denkt so

01:42:03.940 --> 01:42:06.780
Ist die Veranstaltung jetzt

01:42:06.780 --> 01:42:08.600
oder ist

01:42:08.600 --> 01:42:10.120
es gerade irgendwas anderes?

01:42:10.120 --> 01:42:12.020
Naja, das sind alles sehr nette Leute

01:42:12.020 --> 01:42:16.460
Dann, aber genau, vielleicht

01:42:16.460 --> 01:42:18.300
wenn man gerade mit Leuten mal persönlich irgendwie ein bisschen mehr

01:42:18.300 --> 01:42:20.240
reden will, ist das vielleicht ein bisschen besser, weil

01:42:20.240 --> 01:42:22.200
PyDDF ist eher vortragsorientiert

01:42:22.200 --> 01:42:24.340
und immer ein bisschen etwas größerer Rahmen

01:42:24.340 --> 01:42:24.860
Dann gibt es

01:42:24.860 --> 01:42:28.400
das Data Science Meetup in Düsseldorf

01:42:28.400 --> 01:42:30.020
das ist auch mal sehr gut besucht

01:42:30.020 --> 01:42:32.540
wo es häufig um Python-Themen

01:42:32.540 --> 01:42:33.000
auch geht

01:42:33.000 --> 01:42:36.500
QuantFinance bei Jesus Statistik

01:42:36.500 --> 01:42:38.520
für fortgeschrittene Themen auch

01:42:38.520 --> 01:42:40.560
Genau, und dann gibt es

01:42:40.560 --> 01:42:41.940
die Python User Group Köln

01:42:41.940 --> 01:42:44.860
einmal im Monat

01:42:44.860 --> 01:42:46.040
gibt es da ein Treffen, das ist auch

01:42:46.040 --> 01:42:48.580
das ist auch immer meistens so 20-30

01:42:48.580 --> 01:42:50.320
Leute und

01:42:50.320 --> 01:42:52.520
es gibt immer interessante Vorträge, danach geht man

01:42:52.520 --> 01:42:53.700
irgendwo essen

01:42:53.700 --> 01:42:55.680
Ach, das ist bei PyDDF auch so

01:42:55.680 --> 01:42:57.540
Hm

01:42:57.540 --> 01:42:57.740
Hm

01:42:57.740 --> 01:42:58.260
Hm

01:42:58.260 --> 01:43:00.220
Ja, es ist also mehr im Umfeld, wie gesagt, wenn ihr

01:43:00.220 --> 01:43:02.260
irgendwo aus, weiß ich nicht, schieß mich tot, Wien

01:43:02.260 --> 01:43:04.500
München, von der Ostsee

01:43:04.500 --> 01:43:06.540
in der Uckermark, irgendwas findet, dann sagt Bescheid

01:43:06.540 --> 01:43:06.940
Ja

01:43:06.940 --> 01:43:09.140
Da stehen wir hier gerne auch vor

01:43:09.140 --> 01:43:12.540
Ja, ich kann nur sagen, Jochen, vielen Dank

01:43:12.540 --> 01:43:13.460
Ja, danke Dominik

01:43:13.460 --> 01:43:14.400
Ein bisschen schlauer geworden

01:43:14.400 --> 01:43:17.520
Tja, kann's gehen

01:43:17.520 --> 01:43:19.800
Ich hoffe, die Hörer haben auch ein bisschen Spaß gehabt

01:43:19.800 --> 01:43:22.300
Ja, dann bis zur nächsten Folge

01:43:22.300 --> 01:43:23.040
Bis zum nächsten Mal

01:43:23.040 --> 01:43:24.200
Tschö