WEBVTT

00:00:00.000 --> 00:00:04.520
Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python-Podcast in der 15. Episode.

00:00:05.280 --> 00:00:07.940
Hier ist der Dominik, bei mir ist der Jochen, wir sind wieder im Wintergarten.

00:00:08.060 --> 00:00:08.320
Hallo, hallo.

00:00:08.720 --> 00:00:10.620
Es ist sicher, diesmal scheint sogar noch die Sonne zu sein, der Wahnsinn.

00:00:11.000 --> 00:00:14.980
Ja, es ist auch selten, dass wir aufnehmen, wenn es noch hell ist, aber heute...

00:00:14.980 --> 00:00:15.680
Das ist mitten im Winter.

00:00:15.900 --> 00:00:18.840
Ja, wir haben tatsächlich Dezember irgendwie...

00:00:18.840 --> 00:00:21.120
Ja, der 12. Dezember, genau.

00:00:21.560 --> 00:00:23.540
Vielleicht gar nicht so schlecht, wenn wir das mal dazusagen, wenn das ist.

00:00:23.820 --> 00:00:26.600
Ja, wir haben uns ein bisschen Zeit gelassen in letzter Zeit, in den Folgen ist mal so viel zu tun,

00:00:26.600 --> 00:00:31.320
aber wir versprechen, wir werden es nicht aufgeben und euch weiter damit bespaßen können.

00:00:31.540 --> 00:00:32.520
Ich wollte ja nicht belästigen sagen.

00:00:33.160 --> 00:00:34.120
Ja, genau.

00:00:34.480 --> 00:00:37.080
Das ist immer die Frage, was man da empfindet, wenn man das hört.

00:00:37.320 --> 00:00:39.820
Unsere Folge heute soll wirklich mal so eine Anfängerfolge sein.

00:00:41.040 --> 00:00:43.840
Ja, wir werden mit euch heute reden über ein, zwei Fragen, die wir stellen möchten,

00:00:43.960 --> 00:00:50.160
was für Anfänger für Fragen haben oder was mir eingefallen ist oder was einige Hörer uns geschrieben haben.

00:00:51.360 --> 00:00:53.480
Worum es eigentlich bei Python geht, sind ein paar ganz grundlegende Sachen.

00:00:53.980 --> 00:00:54.800
Vielleicht wird es ja spannend.

00:00:55.260 --> 00:00:56.020
Also, ja.

00:00:56.380 --> 00:00:56.580
Keine Leidenschaft.

00:00:56.580 --> 00:00:59.500
Die Lava-Folge kennt ihr schon, wen ihr schon gehört habt.

00:00:59.860 --> 00:01:01.820
Ja, genau.

00:01:02.500 --> 00:01:04.000
Das mit den Themen können wir auch irgendwann mal klassen.

00:01:04.160 --> 00:01:06.360
Wir machen einfach mal nur die nächste Lava-Folge.

00:01:06.620 --> 00:01:06.960
Ja, ja.

00:01:07.600 --> 00:01:10.920
Ja, was machen wir hier eigentlich heute Morgen und was ist so passiert in der Szene?

00:01:11.380 --> 00:01:12.600
Und gibt es irgendwas Neues?

00:01:12.900 --> 00:01:16.620
Nee, nicht, dass ich, ich glaube, seit dem letzten Mal hat sich da gar nicht so viel getan.

00:01:16.920 --> 00:01:17.600
Django 3 ist raus.

00:01:18.160 --> 00:01:18.640
Oh ja, doch.

00:01:18.700 --> 00:01:18.980
Ja, richtig.

00:01:19.140 --> 00:01:19.560
Du hast recht.

00:01:20.140 --> 00:01:20.920
Ja, tatsächlich.

00:01:22.560 --> 00:01:25.560
Django 3 ist raus und das war, das ist natürlich eine tolle Geschichte.

00:01:26.060 --> 00:01:26.560
Ich habe das schon gesagt.

00:01:26.580 --> 00:01:30.360
Ich habe direkt mal versucht zu installieren und da so ein paar Sachen irgendwie mitzumachen.

00:01:30.800 --> 00:01:35.660
Aber habe dann feststellen müssen, dass ein Haufen der Abhängigkeiten, die man so defaultmäßig

00:01:35.660 --> 00:01:40.360
irgendwie in Django-Projekten drin hat, dann nicht mehr so richtig funktioniert haben.

00:01:40.440 --> 00:01:42.760
Beziehungsweise dazu führen, dass man dann halt ein Faceback kriegt, wenn man versucht,

00:01:42.820 --> 00:01:43.860
den Entwicklungsserver zu starten.

00:01:44.900 --> 00:01:50.760
Und ja, unter anderem sowas wie Django Model Utils, was irgendwie fast alle Leute verwenden.

00:01:50.820 --> 00:01:52.080
Oder ich verwende das eigentlich immer.

00:01:52.500 --> 00:01:53.680
Wahrscheinlich auch eine Menge andere Leute.

00:01:53.680 --> 00:01:58.280
Wegen Timestamp Model oder sowas, was man ja oft verwendet.

00:01:58.720 --> 00:02:02.300
Und ich weiß nicht mehr genau, was es noch alles war.

00:02:02.400 --> 00:02:06.680
Es waren, ich habe dann für die Sachen, die nicht funktioniert haben, da habe ich dann

00:02:07.260 --> 00:02:13.940
einfach die gefolgt auf GitHub und habe das dann versucht zu fixen und dann halt entsprechend

00:02:13.940 --> 00:02:15.140
immer Pull Requests aufgemacht.

00:02:16.740 --> 00:02:20.520
Also ihr könntet bei Jochen in den Repos die versuchen, die auch bei Django 3 funktionieren,

00:02:21.000 --> 00:02:21.460
wenn das wollen.

00:02:21.460 --> 00:02:23.540
Nein, das sollte man vielleicht nicht machen.

00:02:23.680 --> 00:02:23.820
Also.

00:02:26.200 --> 00:02:28.000
Darum muss ich das irgendwie kennen oder so.

00:02:28.180 --> 00:02:28.640
Nee, nee, nee, nee.

00:02:29.460 --> 00:02:31.820
Aber es hat mich gewundert, wie viel da noch nicht funktioniert hat.

00:02:31.940 --> 00:02:35.760
Also es waren bei so einem normalen, ich weiß nicht, bei welchem ich das probiert habe,

00:02:35.840 --> 00:02:41.520
entweder bei einer Webseite oder auch bei der Python Podcast Projektdings, habe ich

00:02:41.520 --> 00:02:43.440
mal versucht, das auf Django 3 umzustellen.

00:02:43.800 --> 00:02:49.020
Und das ist mit fünf Einhängigkeiten oder so sind kaputt gegangen.

00:02:49.360 --> 00:02:51.780
Und da habe ich, ich glaube, ich habe auch so fünf Pull Requests irgendwie gemacht.

00:02:52.360 --> 00:02:53.540
Aber danke, bis irgendwie immer drei.

00:02:53.540 --> 00:02:54.440
Oder vier Versionen.

00:02:54.600 --> 00:02:54.960
Oder nee, drei.

00:02:55.100 --> 00:02:56.400
Also null, eins und zwei.

00:02:56.600 --> 00:02:58.020
Und dann ist nämlich ein Major Release.

00:02:58.540 --> 00:02:59.180
Was heißt nochmal was?

00:02:59.240 --> 00:03:01.820
Ich glaube, null ist immer so die neue Feature Sachen.

00:03:02.580 --> 00:03:04.460
Nee, ist immer gerade, ungerade.

00:03:04.940 --> 00:03:06.540
Gerade sind immer die Long Term.

00:03:06.840 --> 00:03:08.120
Ich glaube, zwei ist Long Term.

00:03:08.500 --> 00:03:09.080
Punkt zwei.

00:03:09.200 --> 00:03:12.160
Also 2.2, 1.2, 3.2 sind die Long Term.

00:03:13.340 --> 00:03:13.740
Und eins.

00:03:13.740 --> 00:03:14.920
Ja, kannst du mal nochmal angucken.

00:03:15.060 --> 00:03:16.120
Ich bin mir sicher.

00:03:16.560 --> 00:03:16.980
Okay, gut.

00:03:17.060 --> 00:03:17.300
Sehr gut.

00:03:17.540 --> 00:03:18.820
Und eins ist irgendwas anderes.

00:03:18.880 --> 00:03:19.280
Das weiß ich nicht.

00:03:19.620 --> 00:03:21.080
Aber ja, deswegen habe ich nur gefragt.

00:03:21.080 --> 00:03:22.200
Also was man dann macht.

00:03:22.300 --> 00:03:23.480
Also für Security Patches dann wahrscheinlich.

00:03:23.540 --> 00:03:24.380
Man kann ja nicht mal die 2. Version nehmen,

00:03:24.420 --> 00:03:25.740
dass man irgendwie stabil sein möchte irgendwie.

00:03:26.080 --> 00:03:29.680
Nee, also das, was tatsächlich empfohlen wird eigentlich.

00:03:29.860 --> 00:03:31.340
Also das ist auch so eine Legacy-Geschichte,

00:03:31.540 --> 00:03:32.940
das mit den Long Term Support-Geschichten.

00:03:34.480 --> 00:03:37.880
Und naja, jedenfalls sagt das derjenige,

00:03:38.020 --> 00:03:41.440
der aktuell irgendwie da ja auch hauptruflich

00:03:41.440 --> 00:03:42.660
für das Django-Projekt arbeitet,

00:03:43.840 --> 00:03:44.540
Carlton Gibson,

00:03:45.840 --> 00:03:47.560
dass er empfehlen würde.

00:03:47.560 --> 00:03:50.720
Und das machen eigentlich alle Leute,

00:03:50.920 --> 00:03:53.380
die da wirklich viel Ahnung von haben,

00:03:53.380 --> 00:03:55.680
dass man halt heute, also früher war das wohl mal anders,

00:03:55.680 --> 00:03:58.680
aber mittlerweile sind die neuen Versionen von Django so stabil

00:03:58.680 --> 00:03:59.700
und so gut getestet,

00:03:59.700 --> 00:04:02.080
dass man eigentlich immer möglichst nah dran

00:04:02.080 --> 00:04:03.980
an der Entwicklung bleiben sollte.

00:04:04.880 --> 00:04:06.100
Weil es auch gar nicht mehr so schlimm ist,

00:04:06.160 --> 00:04:08.040
bis dahin abzudaten.

00:04:08.480 --> 00:04:09.540
Es geht gar nicht mehr so viel kaputt.

00:04:09.640 --> 00:04:10.260
Sollte eigentlich nicht.

00:04:10.360 --> 00:04:11.620
Ja, wir haben gerade gesehen, genau.

00:04:12.900 --> 00:04:15.700
Also eigentlich, weil das halt macht halt viele andere Sachen

00:04:15.700 --> 00:04:17.620
deutlich einfacher, wenn man das so rum macht.

00:04:17.780 --> 00:04:20.300
Und wenn man halt auf der Long Term Support-Version sitzt,

00:04:20.460 --> 00:04:23.360
dann hat man halt irgendwann ein großes Problem,

00:04:23.380 --> 00:04:25.640
und das will man vielleicht dann doch nicht.

00:04:25.860 --> 00:04:27.560
Also die Art, wie man das heute macht,

00:04:27.580 --> 00:04:29.240
aber auf der anderen Seite machen das viele Leute schon

00:04:29.240 --> 00:04:30.180
seit langer Zeit so.

00:04:30.640 --> 00:04:32.880
Insofern kann man auch nicht einfach alle so vor den Kopf stoßen.

00:04:33.160 --> 00:04:36.840
Aber so wie man das heute eigentlich machen sollte,

00:04:36.980 --> 00:04:39.240
ist eigentlich immer die aktuellste Django-Version verwenden.

00:04:39.840 --> 00:04:40.580
Ja, okay.

00:04:41.860 --> 00:04:42.980
Und ich versuche das auch immer.

00:04:43.140 --> 00:04:44.060
Und normalerweise funktioniert das,

00:04:44.060 --> 00:04:46.460
also bis jetzt auf die 2. Serie hat das eigentlich sehr gut funktioniert.

00:04:46.560 --> 00:04:48.720
Bis jetzt, Umstieg auf 3, da hat es halt nicht mehr funktioniert.

00:04:49.240 --> 00:04:53.000
Und das war auch in allen Fällen das gleiche Problem.

00:04:53.000 --> 00:04:53.360
Und zwar,

00:04:53.380 --> 00:04:55.360
sind halt so ein paar private APIs

00:04:55.360 --> 00:04:57.660
für die Unterstützung von so alten

00:04:57.660 --> 00:04:59.480
Python 2-Geschichten sind jetzt aus Django 3

00:04:59.480 --> 00:05:01.120
rausgeflogen. Also eigentlich

00:05:01.120 --> 00:05:03.020
gibt es ja keinen Python 2-Support mehr,

00:05:03.080 --> 00:05:04.200
auch seit Django 2 schon nicht mehr.

00:05:04.240 --> 00:05:05.920
Oh, das läuft ja aus. Wir können ja runterzählen.

00:05:06.040 --> 00:05:09.500
Ja, nur noch Tage, bis es irgendwie vorbei ist.

00:05:09.580 --> 00:05:10.460
18, 19.

00:05:11.140 --> 00:05:11.320
Ja.

00:05:13.080 --> 00:05:13.440
Und,

00:05:13.600 --> 00:05:17.320
aber es waren noch so ein paar Geschichten

00:05:17.320 --> 00:05:19.240
dabei. So zum Beispiel, man konnte

00:05:19.240 --> 00:05:21.580
irgendwas, es gab so einen Dekorator

00:05:21.580 --> 00:05:23.360
bei 2 Unicode-Stringen oder so.

00:05:23.380 --> 00:05:25.080
So was, den man über Funktionen setzen konnte.

00:05:25.160 --> 00:05:26.140
Und dann kam das halt mit

00:05:26.140 --> 00:05:29.320
auch den alten Geschichten

00:05:29.320 --> 00:05:30.760
klar. Und

00:05:30.760 --> 00:05:33.300
Six gab es halt auch in Django

00:05:33.300 --> 00:05:34.920
drin. Was auch immer Six ist.

00:05:35.300 --> 00:05:36.820
Ja, auch so eine Geschichte, die einem helfen

00:05:36.820 --> 00:05:39.600
soll, damit umzugehen,

00:05:39.660 --> 00:05:40.220
wenn es halt

00:05:40.220 --> 00:05:43.460
Python 2 und Python 3

00:05:43.460 --> 00:05:44.100
Geschichten sind.

00:05:44.420 --> 00:05:47.340
Wir haben eigentlich versprochen, dass es eine Anfängerfolge

00:05:47.340 --> 00:05:47.860
sein sollte.

00:05:48.360 --> 00:05:50.960
Und wir fangen schon mit der Ahnung ganz tief in die Materie reinzugehen.

00:05:50.960 --> 00:05:52.380
Nee, das ist eigentlich auch nicht so.

00:05:52.480 --> 00:05:53.360
Also es sind ein paar,

00:05:53.380 --> 00:05:55.220
ein paar Hilfsfunktionen, die einem

00:05:55.220 --> 00:05:57.020
dabei helfen, das für 2 und 3,

00:05:57.120 --> 00:05:58.840
Python 2 und 3 gleichzeitig zu machen.

00:05:59.720 --> 00:06:01.340
Die sind jetzt tatsächlich entfernt worden.

00:06:01.420 --> 00:06:03.200
Die waren vorher bloß deprecated, aber jetzt sind

00:06:03.200 --> 00:06:04.060
die halt wirklich weg.

00:06:04.820 --> 00:06:07.160
Und das heißt, wenn jemand die noch verwendet,

00:06:07.620 --> 00:06:09.020
ein Paket die noch verwendet, dann

00:06:09.020 --> 00:06:10.760
gibt es halt ein Traceback an der Stelle.

00:06:10.840 --> 00:06:13.080
Also alles, was jetzt in Python 3 deprecated angezeigt wird,

00:06:13.120 --> 00:06:15.320
ist bei Python 4 dann weg. Bei Python sag ich schon.

00:06:15.500 --> 00:06:16.840
Bei Django 3, 4.

00:06:17.020 --> 00:06:18.880
Ja, also diese Geschichte,

00:06:19.400 --> 00:06:20.820
diese Geschichten waren jetzt halt dann weg.

00:06:20.820 --> 00:06:21.500
Ja, okay.

00:06:21.600 --> 00:06:23.000
Und das hat dann auch,

00:06:23.380 --> 00:06:24.620
ja, also diverse Pakete gebrochen.

00:06:24.800 --> 00:06:27.260
Und insofern, ja, also Umstieg auf Django 3

00:06:27.260 --> 00:06:28.640
nicht so super easy.

00:06:28.840 --> 00:06:30.480
Wie lange ist jetzt Django 2 rausgekommen?

00:06:31.820 --> 00:06:32.580
Wie lange das her ist?

00:06:34.480 --> 00:06:35.700
Ich weiß es nicht mehr genau.

00:06:36.760 --> 00:06:37.780
Ich würde mal so tippen.

00:06:38.000 --> 00:06:38.360
Ages.

00:06:39.040 --> 00:06:40.400
Ja, fast zwei Jahre oder so.

00:06:40.880 --> 00:06:42.200
Irgendwas um die zwei Jahre ein bisschen.

00:06:42.440 --> 00:06:45.460
Ja, also die Release-Zyklen

00:06:45.460 --> 00:06:46.740
bei Django sind ja auch viel kürzer geworden.

00:06:47.040 --> 00:06:49.380
Also das war

00:06:49.380 --> 00:06:50.920
alles viel länger und ja,

00:06:52.280 --> 00:06:53.320
Django 2 gab es jetzt gar nicht so lange.

00:06:53.380 --> 00:06:55.180
Ja, wenn du noch welche News einst,

00:06:55.200 --> 00:06:57.240
weil sonst machen wir tatsächlich weiter mit Content heute.

00:06:57.560 --> 00:06:59.300
Ja, Content klingt gut.

00:07:00.080 --> 00:07:00.880
Also ich stelle jetzt immer

00:07:00.880 --> 00:07:02.760
ein paar blöde Fragen.

00:07:03.580 --> 00:07:03.680
Ja.

00:07:05.140 --> 00:07:07.300
Und ich versuche dich

00:07:07.300 --> 00:07:09.580
dazu zu bringen, dass du die Fragen möglichst kurz beantwortest.

00:07:10.060 --> 00:07:10.760
Also so

00:07:10.760 --> 00:07:12.680
eine Minute pro Frage oder so.

00:07:13.080 --> 00:07:13.660
Vielleicht schaffen wir das.

00:07:13.800 --> 00:07:15.420
Wow, okay. Ja, alles klar.

00:07:16.460 --> 00:07:18.140
Ich weiß, es wird nicht immer ganz einfach bei einigen Themen.

00:07:18.220 --> 00:07:20.720
Es ist natürlich auch was anderes, aber mal gucken.

00:07:21.180 --> 00:07:22.100
Ja, schauen wir einfach mal.

00:07:22.260 --> 00:07:22.900
Also erste Frage.

00:07:23.380 --> 00:07:24.120
Python, eine Schlange.

00:07:26.440 --> 00:07:27.480
Ja, wo kommt der Name her?

00:07:28.000 --> 00:07:30.460
Also, nee, tatsächlich ist das eine Referenz

00:07:30.460 --> 00:07:31.980
auf Monty Python.

00:07:33.240 --> 00:07:35.340
Spam, spam, spam, spam, spam, spam.

00:07:35.520 --> 00:07:36.300
Genau, genau.

00:07:36.760 --> 00:07:38.580
Und auch interessant,

00:07:39.160 --> 00:07:39.280
der

00:07:39.280 --> 00:07:42.380
Monty Pythons

00:07:42.380 --> 00:07:43.460
Flying Circus, also

00:07:43.460 --> 00:07:46.480
der Flying Circus ist wiederum

00:07:46.480 --> 00:07:48.240
eine Anspielung auf, glaube ich,

00:07:48.620 --> 00:07:50.060
Ersten Weltkrieg, Roter Baron

00:07:50.060 --> 00:07:51.780
irgendwie, Geschichte.

00:07:53.380 --> 00:07:54.720
Die nannte man halt,

00:07:55.120 --> 00:07:56.100
das war halt so die

00:07:56.100 --> 00:07:59.760
informelle Bezeichnung, weil die halt immer mit Zelten

00:07:59.760 --> 00:08:01.400
auf irgendwelchen Äckern und Wiesen

00:08:01.400 --> 00:08:03.360
unterwegs waren, weil es sowas wie

00:08:03.360 --> 00:08:04.920
Flugflugplätze ja damals noch gar nicht gab,

00:08:05.380 --> 00:08:06.880
wurden die dann halt auch mal der

00:08:06.880 --> 00:08:07.860
Fliegende Circus genannt.

00:08:09.900 --> 00:08:10.380
Ja,

00:08:10.760 --> 00:08:13.480
aber wo Monty Python

00:08:13.480 --> 00:08:14.420
eigentlich herkommt,

00:08:15.200 --> 00:08:15.780
weiß ich jetzt auch nicht.

00:08:15.780 --> 00:08:18.520
Genau, aber

00:08:18.520 --> 00:08:21.480
die Referenz des Namens

00:08:21.480 --> 00:08:23.360
der Programmiersprache bezieht sich schon auf,

00:08:23.380 --> 00:08:24.300
äh, Monty Python.

00:08:24.940 --> 00:08:26.380
Also ich finde aber eine Schlange eigentlich viel cooler.

00:08:26.580 --> 00:08:28.420
Und ich würde einfach sagen, ich nehme auch immer so eine Schlange als Symbol.

00:08:28.500 --> 00:08:30.040
Und es ist ja sogar im Logo mittlerweile drin.

00:08:30.180 --> 00:08:30.560
Nee, klar.

00:08:32.420 --> 00:08:34.120
Wenn ich mir ganz viele

00:08:34.120 --> 00:08:37.100
Python-Muster auf meinen Körper tätowieren lasse,

00:08:37.160 --> 00:08:38.920
dann ist das natürlich ein Teilchen von meiner Liebe zur

00:08:38.920 --> 00:08:39.600
Sprache.

00:08:41.220 --> 00:08:43.100
Tja, man kann sich ja schlecht nur irgendwelche Gags

00:08:43.100 --> 00:08:44.440
auf den Körper tätowieren lassen, das geht natürlich nicht.

00:08:45.080 --> 00:08:46.400
Ich habe übrigens noch keine Tattoos.

00:08:46.740 --> 00:08:47.820
Leider, meine Frau sagt, ich darf nicht.

00:08:48.400 --> 00:08:48.500
So.

00:08:48.500 --> 00:08:49.540
So, so.

00:08:49.720 --> 00:08:51.520
Tja, da musst du dich wohl entscheiden.

00:08:52.720 --> 00:08:52.900
Ja.

00:08:53.380 --> 00:08:55.220
Also, naja.

00:08:55.220 --> 00:08:56.600
Ja, die nächste Frage wäre, welche

00:08:56.600 --> 00:08:58.480
Einsatzzwecke von Python fallen dir ein?

00:08:59.040 --> 00:08:59.240
Hm.

00:09:01.460 --> 00:09:02.900
Na ja, schon eine ganze Menge, aber ich würde

00:09:02.900 --> 00:09:04.940
sagen, die allerwichtigsten zur Zeit sind

00:09:04.940 --> 00:09:07.180
ja, Data Science

00:09:07.180 --> 00:09:09.000
ist jetzt, glaube ich, das am stärksten

00:09:09.000 --> 00:09:10.320
gehypte Thema momentan.

00:09:10.800 --> 00:09:12.600
Immer noch sogar. Ja, doch, ich denke schon.

00:09:13.060 --> 00:09:14.820
Einfach deswegen, weil das halt irgendwie alle

00:09:14.820 --> 00:09:17.060
machen wollen, weil da auch viele Fortschritte passieren

00:09:17.060 --> 00:09:18.880
und Python ist halt die

00:09:18.880 --> 00:09:21.280
Programmiersprache,

00:09:21.360 --> 00:09:22.960
mit der man das vielleicht am besten machen kann, abgesehen

00:09:22.960 --> 00:09:24.900
von R, aber R ist halt ein bisschen,

00:09:24.900 --> 00:09:26.860
hat ein bisschen einen engeren Einsatzzweck und du kannst halt

00:09:26.860 --> 00:09:29.040
nicht gut Webgeschichten zum Beispiel

00:09:29.040 --> 00:09:30.820
nachschreiben oder so, oder ganze komplette

00:09:30.820 --> 00:09:32.560
Systeme in A bauen, das geht eigentlich nicht gut.

00:09:33.000 --> 00:09:34.560
Aber mit Python geht das, daher ist Python

00:09:34.560 --> 00:09:36.880
irgendwie da schon so

00:09:36.880 --> 00:09:38.840
gerade für produktive Geschichten das

00:09:38.840 --> 00:09:40.900
Mittel der Wahl. Also, wenn man jetzt

00:09:40.900 --> 00:09:42.400
nicht nur Sachen analysieren möchte oder

00:09:42.400 --> 00:09:44.780
explorative Analyse von irgendwas machen möchte, sondern

00:09:44.780 --> 00:09:46.220
man möchte es tatsächlich einsetzen, dann

00:09:46.220 --> 00:09:48.600
kommt man eigentlich um Python nicht wirklich drum herum.

00:09:49.060 --> 00:09:50.620
Es sind ja auch noch so ein paar Leute, die dann irgendwie

00:09:50.620 --> 00:09:52.840
oder sagen wir so, das ist auch ein großer Bereich, aber die

00:09:52.840 --> 00:09:54.900
dann Java oder so verwenden, es gibt ja auch

00:09:54.900 --> 00:09:56.740
irgendwie mit Scala, also

00:09:56.740 --> 00:09:58.540
nicht Java, sondern die Java4M und

00:09:58.540 --> 00:10:00.400
meistens verwenden die Leute dann irgendwie Scala

00:10:00.400 --> 00:10:02.880
obendrauf und Spark

00:10:02.880 --> 00:10:04.240
und da gibt es auch so DataFrames,

00:10:05.160 --> 00:10:06.020
aber

00:10:06.020 --> 00:10:08.720
ich würde sagen, das ist ein

00:10:08.720 --> 00:10:10.500
deutliches Stück kleiner als die Python,

00:10:11.020 --> 00:10:12.320
als der PyDataStack.

00:10:14.180 --> 00:10:14.920
Ja, also

00:10:14.920 --> 00:10:15.960
das ist auf jeden Fall das

00:10:15.960 --> 00:10:18.620
größte Thema, glaube ich, momentan,

00:10:18.700 --> 00:10:20.440
aber Webentwicklung ist nach wie vor auch sehr groß.

00:10:21.720 --> 00:10:22.800
Dann eine Geschichte,

00:10:22.840 --> 00:10:25.000
die jetzt kommt irgendwie,

00:10:26.620 --> 00:10:28.500
da wollen wir auch unbedingt noch mal was zu machen,

00:10:29.240 --> 00:10:30.780
ist alles, was irgendwie so mit

00:10:30.780 --> 00:10:32.660
Home-Automation-Zeugs zu tun hat.

00:10:32.740 --> 00:10:34.400
Home-Assistant ist

00:10:34.400 --> 00:10:36.180
ein großes Thema.

00:10:36.860 --> 00:10:38.880
Ich habe da letztens, weil so um Weihnachten rum,

00:10:38.960 --> 00:10:40.720
dann kann ja auch noch mal gucken, ob diese ganzen

00:10:40.720 --> 00:10:42.320
Geschichten noch gehen oder

00:10:42.320 --> 00:10:44.640
Geschenke in bestimmte Richtungen werfen, die irgendwas

00:10:44.640 --> 00:10:46.700
in der Art tun, weil das ja doch eine ganz

00:10:46.700 --> 00:10:48.640
angenehme Sache ist, wenn man halt

00:10:48.640 --> 00:10:50.440
Lampen und sowas automatisch steuern kann.

00:10:50.820 --> 00:10:52.560
Das ist natürlich ganz spannend, weil man hat halt irgendwie

00:10:52.840 --> 00:10:54.960
ganz viel kleines Zubehör, das irgendwie, wenn ich das richtig

00:10:54.960 --> 00:10:57.180
mal verstehe, meistens so in C am besten programmiert ist.

00:10:57.500 --> 00:10:59.040
Man hat irgendwie so eine High-Level-API, so wie

00:10:59.040 --> 00:11:00.920
MicroPython oder sowas, die man da drauf schmeißt und kann dann einfach

00:11:00.920 --> 00:11:02.700
in Python auch die ganzen Module nehmen.

00:11:04.020 --> 00:11:05.300
Ja, also die ganzen

00:11:05.300 --> 00:11:07.320
Endgeräte,

00:11:07.440 --> 00:11:08.940
das ist ja die Frage. Also man kann das, wenn es

00:11:08.940 --> 00:11:10.900
so was Arduino-mäßig ist, dann ist das auf C,

00:11:10.980 --> 00:11:12.200
was man da normalerweise schreibt, aber

00:11:12.200 --> 00:11:14.640
es gibt halt auch mittlerweile Chips,

00:11:15.060 --> 00:11:17.220
auf denen man MicroPython

00:11:17.220 --> 00:11:18.920
installieren kann und dann kann man da einfach Python schreiben.

00:11:18.920 --> 00:11:20.960
Die haben halt WLAN und ansonsten

00:11:20.960 --> 00:11:22.660
hast du ein Problem, wie kommunizierst du eigentlich mit

00:11:22.660 --> 00:11:25.100
Sensoren oder irgendwelchen Dingen, die dann was schalten oder so.

00:11:26.700 --> 00:11:27.280
Wenn du da

00:11:27.280 --> 00:11:28.980
irgendwie das über Funk, DVB-T

00:11:28.980 --> 00:11:30.660
oder so machen, also ein bisschen ätzend

00:11:30.660 --> 00:11:32.960
und WLAN ist natürlich schon nicht so schlecht und das geht

00:11:32.960 --> 00:11:34.920
eigentlich mit alles mittlerweile, aber halt eben,

00:11:35.020 --> 00:11:36.940
ich glaube, der größte Punkt ist, dass Home Assistant

00:11:36.940 --> 00:11:38.880
ist halt in Python geschrieben und das ist halt

00:11:38.880 --> 00:11:40.980
das Ding, was zum Verwalten von diesem ganzen Kram halt

00:11:40.980 --> 00:11:42.620
üblicherweise so verwendet wird.

00:11:43.040 --> 00:11:44.100
Wir haben ja jetzt nicht irgendeine fertige

00:11:44.100 --> 00:11:46.180
Lösung wie jetzt,

00:11:46.400 --> 00:11:47.620
na, wie heißt das denn,

00:11:48.720 --> 00:11:49.140
von Apple?

00:11:49.680 --> 00:11:51.880
Ja, hast du nicht gesehen.

00:11:52.660 --> 00:11:54.800
Ja, oder Google

00:11:54.800 --> 00:11:56.820
oder Amazon oder so, die haben

00:11:56.820 --> 00:11:57.820
natürlich ihre eigenen Geschichten.

00:11:59.580 --> 00:12:00.780
Und was ich da interessant, ich habe da

00:12:00.780 --> 00:12:02.620
letztens nochmal, genau in dem Zusammenhang, mir

00:12:02.620 --> 00:12:04.620
dieses State of the Union von Home Assistant

00:12:04.620 --> 00:12:07.020
den Talk angeguckt und

00:12:07.020 --> 00:12:10.840
das war mir gar nicht so

00:12:10.840 --> 00:12:12.700
klar, dass die mittlerweile unter den

00:12:12.700 --> 00:12:14.240
Top Ten der

00:12:14.240 --> 00:12:16.380
Projekte bei GitHub sind, die am meisten

00:12:16.380 --> 00:12:17.780
Contributions kriegen.

00:12:18.860 --> 00:12:20.420
Aber die würden am meisten gerne daran basteln, ne?

00:12:20.420 --> 00:12:22.220
Ja, ich war eigentlich,

00:12:22.660 --> 00:12:24.060
überrascht, wie viel das ist, weil

00:12:24.060 --> 00:12:26.640
das ist ja jetzt eben noch nicht so prominent.

00:12:27.320 --> 00:12:28.640
Ich glaube, es waren sowieso sehr wenig

00:12:28.640 --> 00:12:30.200
Open Source Projekte in den ersten zehn.

00:12:30.900 --> 00:12:32.740
Also da waren eher solche, das fand ich

00:12:32.740 --> 00:12:33.720
auch so ein bisschen erschreckend.

00:12:33.960 --> 00:12:35.160
Wir haben doch keine Zeit.

00:12:36.180 --> 00:12:37.940
Aber sowas wie Visual Studio zum Beispiel,

00:12:38.600 --> 00:12:40.600
VS Code oder so ist in den

00:12:40.600 --> 00:12:42.420
Top Ten, TensorFlow und so,

00:12:42.480 --> 00:12:44.460
das sind ja alles nur so mehr oder weniger Open Source Projekte,

00:12:44.540 --> 00:12:46.580
nicht so richtig eigentlich, aber Home Assistant schon.

00:12:47.260 --> 00:12:48.780
Also, ja, da geht auf jeden Fall

00:12:48.780 --> 00:12:49.940
auch noch was. Und

00:12:49.940 --> 00:12:52.420
ansonsten, ja, alles, was

00:12:52.660 --> 00:12:53.740
wir noch so an

00:12:53.740 --> 00:12:57.040
Server-Infrastrukturen automatisch hochziehen,

00:12:58.340 --> 00:12:59.020
Deployment,

00:12:59.340 --> 00:13:00.500
da ist Python auch sehr stark

00:13:00.500 --> 00:13:01.380
vertreten.

00:13:01.440 --> 00:13:02.740
Das heißt, Web, hat man doch so ganz kurz gesagt,

00:13:02.840 --> 00:13:04.280
ist gar nicht so klein, oder?

00:13:04.360 --> 00:13:06.140
Nee, Web ist auch sehr groß, ja. Also

00:13:06.140 --> 00:13:09.040
Django und Flask sind ungefähr beide gleich

00:13:09.040 --> 00:13:09.980
groß, mehr oder weniger.

00:13:11.620 --> 00:13:13.180
Und es sind beides große

00:13:13.180 --> 00:13:15.020
Bereiche.

00:13:15.980 --> 00:13:16.660
Viele der

00:13:16.660 --> 00:13:19.040
Top-Seiten sind irgendwie eins von beiden.

00:13:20.240 --> 00:13:21.100
Also, genau.

00:13:21.340 --> 00:13:21.440
Also,

00:13:22.660 --> 00:13:24.660
ziemliche Allround-Sprache eigentlich, kann man sagen.

00:13:24.960 --> 00:13:25.360
Ja, okay.

00:13:26.260 --> 00:13:27.400
Kann man fast alles mitmachen.

00:13:28.400 --> 00:13:30.100
Was sollte man in Python können, um einen Job zu bekommen?

00:13:31.960 --> 00:13:32.320
Hmm.

00:13:33.800 --> 00:13:34.960
Das, äh,

00:13:35.040 --> 00:13:35.500
äh,

00:13:36.120 --> 00:13:36.380
hm.

00:13:38.780 --> 00:13:40.260
Ich weiß nicht. Also, ich glaube, da kann man,

00:13:40.400 --> 00:13:41.820
das ist immer ein bisschen schwer, ne?

00:13:41.960 --> 00:13:44.240
Wenn man das dann sagt, was Leute da machen sollen,

00:13:44.700 --> 00:13:45.820
und dann sagt irgendwie die Library

00:13:45.820 --> 00:13:48.200
oder das, was besonders interessant zur Zeit,

00:13:48.260 --> 00:13:50.360
dann braucht man irgendwie eine gewisse Zeit, um das zu lernen.

00:13:50.760 --> 00:13:52.480
Wobei die meiste Zeit, die man braucht, um das zu lernen,

00:13:52.480 --> 00:13:53.500
wahrscheinlich dabei drauf geht,

00:13:54.020 --> 00:13:56.120
programmieren zu lernen. Das dauert halt einfach lange.

00:13:57.040 --> 00:13:58.500
Und dann ist es halt in dem Moment, wo man es kann,

00:13:58.540 --> 00:14:00.220
wieder veraltet. Also, insofern, das hilft alles nicht.

00:14:00.540 --> 00:14:02.220
Aber ich würde sagen, tatsächlich,

00:14:02.380 --> 00:14:04.340
die Geschichte, die am meisten bringt

00:14:04.340 --> 00:14:06.480
und von der aus man dann alle anderen

00:14:06.480 --> 00:14:08.140
Sachen, die man vielleicht lernen kann, ist halt

00:14:08.140 --> 00:14:10.440
tatsächlich einfach richtig programmieren können.

00:14:10.520 --> 00:14:11.420
Das ist schon so die

00:14:11.420 --> 00:14:14.580
Fähigkeit, die man

00:14:14.580 --> 00:14:16.720
haben sollte. Oder es ist halt auch etwas, was nicht so...

00:14:16.720 --> 00:14:18.480
Es ist ja, äh, ja...

00:14:19.020 --> 00:14:20.180
Richtig programmieren können, das hört sich jetzt

00:14:20.180 --> 00:14:22.180
total einfach an. Das hört sich total einfach an, aber das ist

00:14:22.180 --> 00:14:24.340
tatsächlich nicht so verbreitet, wie man

00:14:24.340 --> 00:14:26.480
sich das wünschen würde.

00:14:26.720 --> 00:14:28.380
Also, das kann man immer...

00:14:28.380 --> 00:14:30.060
Man denkt immer so, ja, das macht man halt irgendwie.

00:14:30.160 --> 00:14:31.540
Dann machen Leute irgendwie einen Kurs oder

00:14:31.540 --> 00:14:33.620
kaufen sich irgendwie, ich weiß nicht, ob es sowas überhaupt gibt,

00:14:33.700 --> 00:14:35.200
Python in 21 Tagen oder Java.

00:14:36.600 --> 00:14:38.080
Das geht nicht in 21 Tagen.

00:14:38.200 --> 00:14:40.180
Das geht auch nicht in einem halben Jahr. Das dauert alles

00:14:40.180 --> 00:14:42.100
ein bisschen länger. Ja, manche Leute denken ja,

00:14:42.160 --> 00:14:43.880
dass, wenn sie die Syntax mal einmal gesehen haben...

00:14:43.880 --> 00:14:46.400
Genau, dass das das Gleiche wäre. Aber das stimmt halt nicht.

00:14:46.720 --> 00:14:47.660
Es ist...

00:14:47.660 --> 00:14:49.980
Die Syntax ist ja auch bei Programmiersprachen eigentlich

00:14:49.980 --> 00:14:51.620
gar nicht so...

00:14:51.620 --> 00:14:53.820
Also, für Anfänger schon. Die verstehen ja erst mal überhaupt nicht,

00:14:53.860 --> 00:14:55.800
was da steht. Das ist der erste Schritt zum

00:14:55.800 --> 00:14:57.320
Verstehen, was überhaupt, worum es überhaupt geht.

00:14:57.420 --> 00:14:59.380
Ja, aber wenn man das eben mit einer natürlichen Sprache vergleicht,

00:14:59.420 --> 00:15:01.480
es gibt halt viel weniger Worte. Es gibt halt ein paar,

00:15:01.720 --> 00:15:02.760
äh, ja,

00:15:03.060 --> 00:15:05.800
es gibt ein paar Verben

00:15:05.800 --> 00:15:07.480
sozusagen für Worte. Hast du aber die ganze

00:15:07.480 --> 00:15:08.540
Standard-Library mit bedacht?

00:15:09.180 --> 00:15:11.180
Klar, also die Libraries sind ja nochmal ein anderes Thema,

00:15:11.480 --> 00:15:13.660
aber das muss man ja auch alles gar nicht so unbedingt können.

00:15:14.760 --> 00:15:15.680
Ähm, man muss halt,

00:15:15.780 --> 00:15:17.600
wenn man die Syntax und halt die paar

00:15:17.600 --> 00:15:19.620
Worte, die es tatsächlich gibt, kann,

00:15:19.620 --> 00:15:21.320
dann kann man das ja zumindest mal alles lesen.

00:15:21.620 --> 00:15:23.620
Und, ja, also, ähm,

00:15:24.360 --> 00:15:25.540
ja, das ist halt, also programmieren

00:15:25.540 --> 00:15:27.660
können ist aber so ein bisschen wie ein Musikinstrument

00:15:27.660 --> 00:15:29.760
können oder halt auch Fremdsprache

00:15:29.760 --> 00:15:31.600
lernen oder so. Und das ist halt so eine Geschichte, die dauert

00:15:31.600 --> 00:15:33.740
einfach. Äh, da gibt's dann halt auch

00:15:33.740 --> 00:15:35.640
Sachen, wie man das schneller hinkriegt und, äh, wie man das

00:15:35.640 --> 00:15:37.500
effektiver üben kann und so. Und, ähm,

00:15:38.300 --> 00:15:39.080
äh, aber

00:15:39.080 --> 00:15:41.620
das, äh, aber wenn man das dann kann, dann

00:15:41.620 --> 00:15:43.620
äh, kann man sich

00:15:43.620 --> 00:15:45.680
eigentlich in jedes Thema relativ schnell

00:15:45.680 --> 00:15:47.580
einarbeiten, würde ich jetzt mal so einfach sagen.

00:15:47.580 --> 00:15:49.580
Ja. Und, äh, das ist halt

00:15:49.580 --> 00:15:51.220
auch, denke ich, also die entscheidende,

00:15:51.620 --> 00:15:53.560
äh, Geschichte, äh, die man, die man

00:15:53.560 --> 00:15:54.720
können sollte, ähm.

00:15:55.260 --> 00:15:57.220
Solche Themen schnell einarbeiten. Ja,

00:15:57.480 --> 00:15:59.520
beziehungsweise halt diese... Die Prinzipien des Programmierens.

00:15:59.640 --> 00:16:01.360
Diese, diese Geschichte, die halt lange dauert, halt schon

00:16:01.360 --> 00:16:03.020
vorher erledigt haben, weil das, äh,

00:16:03.680 --> 00:16:05.240
wird einem niemand gerne bezahlt,

00:16:05.460 --> 00:16:07.160
weil, äh, das ist einfach das

00:16:07.160 --> 00:16:09.680
lange Dauertum. Aber ich würde auch

00:16:09.680 --> 00:16:11.080
sagen, da gibt's halt, äh, ein neues Potenzial.

00:16:11.220 --> 00:16:13.460
Jetzt hört sich so ein bisschen an, das kann das ja jeder, aber das ist

00:16:13.460 --> 00:16:14.620
nicht so. Also die allermeisten

00:16:14.620 --> 00:16:17.500
haben damit Probleme und, und strugglen da

00:16:17.500 --> 00:16:18.740
und das, äh, nur ein,

00:16:19.240 --> 00:16:21.560
ein, ein, nicht, nicht die Mehrheit aller Programmierer,

00:16:21.560 --> 00:16:21.600
äh, haben damit Probleme und, und strugglen da.

00:16:21.620 --> 00:16:23.340
Man kann ordentlich programmieren, würde ich jetzt mal so sagen, ne?

00:16:24.000 --> 00:16:25.520
Ja, das musst du eigentlich noch definieren, was denn

00:16:25.520 --> 00:16:27.320
ordentlich programmieren muss. Und, und, das ist vielleicht auch, das ist auch vielleicht,

00:16:27.360 --> 00:16:29.420
ja, das, das kann ich, ehrlich gesagt, gar nicht so genau.

00:16:29.660 --> 00:16:31.440
Und, äh, ist auch die Frage, ob, eigentlich

00:16:31.440 --> 00:16:33.220
ist es auch wieder so ein bisschen, ne, äh,

00:16:33.220 --> 00:16:35.100
ich will eigentlich niemanden ausschließen,

00:16:35.460 --> 00:16:36.700
äh, ich,

00:16:36.940 --> 00:16:39.520
ich würde sagen, ja, selbst wenn man das nicht so total

00:16:39.520 --> 00:16:41.460
hundertprozentig kann, wahrscheinlich haben die

00:16:41.460 --> 00:16:43.560
meisten von uns auch schon irgendwie, äh,

00:16:43.640 --> 00:16:45.460
Jobs gemacht, wo sie dachten, dass sie dafür, äh,

00:16:45.460 --> 00:16:47.540
eigentlich gar nicht geeignet wären oder so und das haben dann halt

00:16:47.540 --> 00:16:49.460
irgendwie gelernt, ja. Ich meine, so ist

00:16:49.460 --> 00:16:51.280
das halt auch, äh, normal. Das ist wahrscheinlich

00:16:51.280 --> 00:16:53.160
auch in anderen Bereichen so und, ähm,

00:16:54.080 --> 00:16:55.380
vielleicht muss man sich einfach mal trauen,

00:16:55.460 --> 00:16:57.320
irgendwas zu machen oder zu sagen, dass man irgendwas kann,

00:16:57.400 --> 00:16:59.200
auch wenn man es halt vielleicht nur so ein bisschen kann und dann nicht so

00:16:59.200 --> 00:17:02.380
perfekt, ne, dann, ja.

00:17:02.960 --> 00:17:03.580
Ja, aber du musst

00:17:03.580 --> 00:17:05.340
ja trotzdem dabei rausfinden, was denn jetzt, äh, richtiges

00:17:05.340 --> 00:17:07.360
Programmieren dann überhaupt ist. Also, das ist jetzt zwar eigentlich jetzt nicht

00:17:07.360 --> 00:17:09.180
auf meiner Liste, aber da musst du jetzt ein kleines

00:17:09.180 --> 00:17:10.660
Kofotos teilen. Ich hab ja sogar zwei Minuten.

00:17:12.300 --> 00:17:12.580
Naja,

00:17:13.540 --> 00:17:15.420
äh, das wäre gar kein Problem, wenn das in zwei Minuten

00:17:15.420 --> 00:17:17.220
zwei Minuten, sag ich mal. Äh, also ich,

00:17:17.500 --> 00:17:19.100
ich würde sagen, also wenn man halt

00:17:19.100 --> 00:17:20.860
keine, nichts total

00:17:20.860 --> 00:17:21.100
äh,

00:17:21.280 --> 00:17:23.240
also wenn man Dinge so macht, wie sie

00:17:23.240 --> 00:17:25.140
gemacht werden sollten, nicht so

00:17:25.140 --> 00:17:27.280
total schrecklich Dinge falsch macht, vielleicht.

00:17:28.080 --> 00:17:29.300
Weil tatsächlich ist es das, was man

00:17:29.300 --> 00:17:31.020
oft sieht, dass Sachen halt wirklich, also

00:17:31.020 --> 00:17:32.900
nicht, nicht nur so ein bisschen

00:17:32.900 --> 00:17:34.760
nicht ordentlich sind, sondern

00:17:34.760 --> 00:17:37.240
so Kleinigkeiten, sondern dass so Dinge so gar nicht

00:17:37.240 --> 00:17:39.020
richtig sind eigentlich. Was, was gehört denn dazu?

00:17:39.160 --> 00:17:41.260
Also was würde denn da? Also ich würde, ich würde

00:17:41.260 --> 00:17:43.260
sagen, eben das, äh, den, der Umgang mit den,

00:17:43.400 --> 00:17:45.480
äh, mit den ganz einfachen

00:17:45.480 --> 00:17:46.940
äh, Datenstrukturen,

00:17:47.620 --> 00:17:48.860
ja, also irgendwie

00:17:48.860 --> 00:17:50.540
Listen, Dicks,

00:17:50.540 --> 00:17:52.580
äh, irgendwie

00:17:52.580 --> 00:17:54.240
Skalare und damit halt ordentlich umgehen kann.

00:17:54.340 --> 00:17:56.020
Also wenn man das schon kann, ist schon viel.

00:17:56.480 --> 00:17:58.600
Hat man schon viel. Äh, weil das

00:17:58.600 --> 00:18:00.260
schon viele Leute nicht so richtig hinkriegen.

00:18:00.580 --> 00:18:02.220
Und, ähm, ja,

00:18:02.360 --> 00:18:04.360
dann halt, äh,

00:18:04.800 --> 00:18:06.060
dass man eben

00:18:06.060 --> 00:18:08.300
Sachen halt ordentlich in Funktionen packt, nicht irgendwie

00:18:08.300 --> 00:18:10.940
Spaghetti-Gut schreibt, dass das halt alles so halbwegs, äh,

00:18:11.040 --> 00:18:12.440
sondern sich nicht dauernd wiederholt.

00:18:13.220 --> 00:18:14.460
Dry, don't criticize yourself.

00:18:15.520 --> 00:18:16.620
Ja, und, und

00:18:16.620 --> 00:18:18.400
die ganzen, aber da gehen wir fast schon

00:18:18.400 --> 00:18:20.420
in diese Detailgeschichten, oder dass man halt,

00:18:20.540 --> 00:18:22.620
äh, Tests schreibt und diese ganzen Best Practices,

00:18:22.860 --> 00:18:24.880
äh, verwendet und Versionskontrolle

00:18:24.880 --> 00:18:25.440
verwendet und so.

00:18:25.660 --> 00:18:28.460
Mit den Daten, das muss ich später nochmal sagen, da hab ich noch ein paar Fragen, da, ähm,

00:18:28.460 --> 00:18:30.540
müssen wir nochmal ein bisschen drauf eingehen, was denn überhaupt jetzt, ähm,

00:18:30.580 --> 00:18:32.760
Skalar, Datenschule, was alles ist, ja.

00:18:33.240 --> 00:18:34.620
Ja. Okay, also du sagst halt

00:18:34.620 --> 00:18:36.340
einfach, okay, man muss halt die Prinzipien, Best Practices

00:18:36.340 --> 00:18:38.380
irgendwie kennen und anwenden und sich daran so ein bisschen

00:18:38.380 --> 00:18:40.540
hochhangeln und irgendwie sich was besorgen, was

00:18:40.540 --> 00:18:42.600
man da... Ja, und viel Code lesen, halt

00:18:42.600 --> 00:18:44.180
viel sich mal angucken, was...

00:18:44.180 --> 00:18:46.440
Das Problem ist natürlich, wenn man jetzt jemanden liest, wo du sagst,

00:18:46.480 --> 00:18:48.260
dass die Mehrheit der Programmierer ist gar nicht so

00:18:48.260 --> 00:18:50.380
hervorragend, und dann lese ich jetzt

00:18:50.380 --> 00:18:51.600
von... Oder wie lese ich davon?

00:18:51.960 --> 00:18:54.640
Ich würde sagen, da ist viel Verbesserungspotenzial.

00:18:54.740 --> 00:18:55.940
Also wenn man sich anguckt, was, was,

00:18:55.940 --> 00:18:57.920
wenn der Code, der geschrieben wird von Leuten

00:18:57.920 --> 00:19:00.100
oder der so in Firmen, äh, äh, läuft

00:19:00.100 --> 00:19:01.900
oder so, ist das dann so, wie es sein könnte, oder

00:19:01.900 --> 00:19:03.360
kann da noch, geht da noch mehr?

00:19:03.820 --> 00:19:06.040
Und da muss man sagen, da geht eigentlich fast immer

00:19:06.040 --> 00:19:07.900
noch deutlich mehr. Ja gut, aber wenn man

00:19:07.900 --> 00:19:09.260
sich jetzt einen eigenen Code anguckt, dann

00:19:09.260 --> 00:19:11.660
ein halbes Jahr später, dann denkt man natürlich schon so, oh, oh, was ist das?

00:19:11.660 --> 00:19:13.160
Ja, das ist auch so, ja.

00:19:13.840 --> 00:19:15.820
Äh, genau. Aber, äh, ja.

00:19:17.260 --> 00:19:18.200
Ja, was,

00:19:18.260 --> 00:19:19.960
äh, erstmal, also ich habe noch eine Basisfrage

00:19:19.960 --> 00:19:21.420
bekommen vom, vom Olli, der hatte noch geschrieben,

00:19:21.500 --> 00:19:24.280
Tipps für eine gute Syntax, also dein Top 5

00:19:24.280 --> 00:19:26.380
oder so. Äh, ich,

00:19:26.600 --> 00:19:28.360
heute, heutzutage würde ich sagen, Black verwenden

00:19:28.360 --> 00:19:29.600
und nicht mehr drüber nachdenken.

00:19:30.780 --> 00:19:32.080
Also einfach Black, bumm. Ja.

00:19:32.900 --> 00:19:34.280
Vielleicht, also Namen vielleicht auch, äh,

00:19:35.140 --> 00:19:36.380
muss man vielleicht... Namen sind natürlich

00:19:36.380 --> 00:19:38.260
das sind ganz, ganz, ganz, das ist eine ganz schwierige

00:19:38.260 --> 00:19:40.280
Sache, also wie kommt man da auf gute Namen, da muss man

00:19:40.280 --> 00:19:41.860
auch lange drüber nachdenken oft, äh,

00:19:42.240 --> 00:19:44.300
also, äh, ja, das gibt, da gibt es ja auch

00:19:44.300 --> 00:19:46.280
den bekannten Witz, ne, wie, was sind

00:19:46.280 --> 00:19:47.300
die zwei schwierigen Sachen?

00:19:47.300 --> 00:19:49.840
Äh, ähm, ja, äh,

00:19:49.840 --> 00:19:52.140
in der Informatik, äh,

00:19:52.200 --> 00:19:54.040
irgendwie Dinge benennen, äh,

00:19:54.040 --> 00:19:55.800
Caching und, und oft bei One Error

00:19:55.800 --> 00:19:57.020
erhors.

00:19:57.680 --> 00:20:00.180
Ja, aber, äh, genau. Also, äh,

00:20:00.260 --> 00:20:01.820
Dinge benennen ist, ist, ist schwierig,

00:20:01.940 --> 00:20:04.080
ist eine Kunst und, ähm, ja, wo man

00:20:04.080 --> 00:20:06.220
sich da auch dran orientieren kann, ist so ein bisschen

00:20:06.220 --> 00:20:07.620
wie bei, bei guten Kommentaren.

00:20:08.080 --> 00:20:09.340
So sollte eher darauf achten,

00:20:09.480 --> 00:20:11.960
hinzuschreiben, warum man das macht oder

00:20:11.960 --> 00:20:13.780
was das macht. Nicht so sehr,

00:20:14.100 --> 00:20:15.620
wie da irgendwas passiert oder so.

00:20:15.620 --> 00:20:16.620
Äh, äh,

00:20:17.300 --> 00:20:19.540
ja, und halt dabei,

00:20:19.900 --> 00:20:21.580
wenn man verschreibt, äh, äh,

00:20:21.740 --> 00:20:23.500
dran denken, dass das, äh,

00:20:24.000 --> 00:20:25.640
wenn das, äh, jemand liest,

00:20:25.700 --> 00:20:27.580
dann halt verständlich sein sollte, weil Code

00:20:27.580 --> 00:20:28.860
viel öfter gelesen wird als geschrieben.

00:20:30.020 --> 00:20:30.920
Ja. Okay.

00:20:31.900 --> 00:20:34.060
Ähm, was ist mit sowas wie List Comprehension?

00:20:34.240 --> 00:20:35.780
Würdest du das bevorzugen gegenüber

00:20:35.780 --> 00:20:37.640
klassischen Loops? Nö, kommt, kommt

00:20:37.640 --> 00:20:39.720
drauf an. Also, äh, ich würde sogar eher

00:20:39.720 --> 00:20:41.780
ein bisschen, die andere, ich würde

00:20:41.780 --> 00:20:43.360
sagen, lieber eine, eine, eine

00:20:43.360 --> 00:20:45.920
Vorschleife verwenden und List Comprehension

00:20:45.920 --> 00:20:47.280
halt eher dann, wenn es halt,

00:20:47.300 --> 00:20:49.180
irgendwas Einfaches ist, wo,

00:20:49.980 --> 00:20:51.240
ja, wenn es halt offensichtlich und

00:20:51.240 --> 00:20:52.880
einfach ist, dann kann man auch gerne

00:20:52.880 --> 00:20:55.260
List Comprehension verwenden, aber wenn

00:20:55.260 --> 00:20:57.660
man, also, ich meine, ähm,

00:20:58.620 --> 00:20:59.380
auch da, auch da,

00:20:59.460 --> 00:21:01.260
das ist halt, wenn man irgendwas entdeckt, wie es

00:21:01.260 --> 00:21:03.240
funktioniert und das dann cool findet, dann fängt man an, das überall

00:21:03.240 --> 00:21:05.200
zu benutzen und, äh, ich habe dann auch schon

00:21:05.200 --> 00:21:07.100
nicht List Comprehensions gebaut, äh, irgendwie,

00:21:07.660 --> 00:21:09.380
wo ich dann halt, äh, ähm,

00:21:09.700 --> 00:21:11.160
mehrfach verschachtelt irgendwie

00:21:11.160 --> 00:21:13.220
über Dinge iteriert habe und das wird bei

00:21:13.220 --> 00:21:14.920
List Comprehension sehr, sehr schnell, sehr, sehr

00:21:15.400 --> 00:21:16.900
unübersichtlich, ja, wo ich dann halt irgendwie,

00:21:16.900 --> 00:21:19.000
äh, stolz darauf war, so ein Statement hingekriegt zu haben,

00:21:19.240 --> 00:21:21.560
äh, also, äh, nicht in einer

00:21:21.560 --> 00:21:22.880
Zeile, das geht dann halt nicht mehr in einer Zeile,

00:21:22.980 --> 00:21:25.100
aber dann so drei Zeilen, List Comprehension

00:21:25.100 --> 00:21:26.960
irgendwie, äh, mit Bedingungen

00:21:26.960 --> 00:21:28.680
drin und verschachtelt und, äh,

00:21:28.800 --> 00:21:31.100
so lange getüftelt, bis es irgendwie ordentlich funktioniert hat,

00:21:31.280 --> 00:21:32.760
das macht ja dann auch irgendwie Spaß,

00:21:32.840 --> 00:21:34.880
das ist halt so ein bisschen wie puzzeln, aber

00:21:34.880 --> 00:21:37.180
ich fürchte, wenn da jemand dann draufguckt,

00:21:37.260 --> 00:21:38.060
der das, äh,

00:21:38.060 --> 00:21:40.880
der das verstehen muss und das unter dem

00:21:40.880 --> 00:21:43.160
gewissen Zeitdruck tut, dann, äh,

00:21:43.160 --> 00:21:45.300
würde der sich wahrscheinlich irgendwie, äh,

00:21:45.300 --> 00:21:46.080
rot vor Hut,

00:21:46.900 --> 00:21:49.220
Spaß zur Ärger, da würde sich das,

00:21:49.520 --> 00:21:51.340
äh, da gibt's, äh, das Remote

00:21:51.340 --> 00:21:53.100
Strangulation-Protokoll irgendwie

00:21:53.100 --> 00:21:55.060
zu Hilfe wünschen. Das Remote?

00:21:55.280 --> 00:21:55.740
Ja.

00:21:56.440 --> 00:21:59.700
Ähm, ich weiß nicht, ähm,

00:22:00.500 --> 00:22:01.380
äh, äh,

00:22:01.440 --> 00:22:03.240
ja, das kennt wahrscheinlich auch keiner, äh, damals

00:22:03.240 --> 00:22:05.360
gab's so ein Text, äh, auch schon lange

00:22:05.360 --> 00:22:07.440
her, äh, Bastard Operator from Hell

00:22:07.440 --> 00:22:09.240
und, äh,

00:22:09.320 --> 00:22:11.240
da gibt's die SysAdmin, äh,

00:22:11.320 --> 00:22:13.520
also es gibt die SysAdmin-Man-Pages oder die, äh,

00:22:13.520 --> 00:22:15.080
äh, äh, Sys, äh,

00:22:15.160 --> 00:22:16.880
äh, Admin Recovery gab's in den News,

00:22:16.900 --> 00:22:17.220
äh, News Group

00:22:17.220 --> 00:22:20.560
und dann, äh, ASR, ne?

00:22:20.820 --> 00:22:22.820
Alt SysAdmin Recovery, das war

00:22:22.820 --> 00:22:25.120
die News Group und dann gab's die ASR-Man-Pages

00:22:25.120 --> 00:22:26.860
und Tools, äh, ich glaub, wenn man

00:22:26.860 --> 00:22:29.000
Man-ASR sagt

00:22:29.000 --> 00:22:30.960
oder Man-Knife oder Man-

00:22:30.960 --> 00:22:32.860
Snip oder so, dann kriegt man das

00:22:32.860 --> 00:22:34.300
auch noch, äh, irgendwie auf dem Linux,

00:22:34.520 --> 00:22:36.780
äh, zu sehen, da gibt's dann Tools, mit

00:22:36.780 --> 00:22:38.240
denen man, äh, irgendwie Usern,

00:22:39.580 --> 00:22:40.880
äh, die, die

00:22:40.880 --> 00:22:42.700
Attitüde, äh, Attitüde von, von Usern wieder,

00:22:42.860 --> 00:22:44.480
äh, re, re, rejustieren kann

00:22:44.480 --> 00:22:46.480
und diese Tools sind halt sowas wie, äh,

00:22:46.900 --> 00:22:47.380
Snip

00:22:47.380 --> 00:22:50.800
oder Knife ist da, ächs,

00:22:51.340 --> 00:22:52.760
ja, so, mit der Axt

00:22:52.760 --> 00:22:54.660
irgendwie mal dazwischen geht und, äh, Dinge

00:22:54.660 --> 00:22:56.180
gerade richtet und, äh,

00:22:56.180 --> 00:22:58.260
Regulieren, das hört sich toll an.

00:22:58.880 --> 00:23:01.560
Ja, das klingt, äh, klingt nach Spaß an,

00:23:01.660 --> 00:23:03.060
äh, wenn man auf der richtigen Seite steht.

00:23:03.620 --> 00:23:04.920
Äh, ja, ist natürlich

00:23:04.920 --> 00:23:06.800
so ein bisschen, ich mein, das Mindset dahinter ist

00:23:06.800 --> 00:23:08.920
auch etwas fragwürdig, aber es ist damals

00:23:08.920 --> 00:23:10.860
was irgendwie lustig und, äh, eines

00:23:10.860 --> 00:23:12.840
der, da gab's auch Protokolle und eines der Protokolle

00:23:12.840 --> 00:23:14.760
in dem Zusammenhang ist halt, dass, äh,

00:23:14.760 --> 00:23:16.760
äh, es, äh, äh,

00:23:16.900 --> 00:23:18.760
RSCP, RS, äh,

00:23:18.820 --> 00:23:21.280
äh, eben, Remote Strangulation Protokoll

00:23:21.280 --> 00:23:22.760
mit einer Software über

00:23:22.760 --> 00:23:24.740
Fernverbindungen.

00:23:25.240 --> 00:23:26.900
Sehr gut. Ja, also, ne,

00:23:26.920 --> 00:23:28.960
das ist das, was man in Startorganisationen

00:23:28.960 --> 00:23:30.780
gerne hätte oder wo man dran arbeitet, das auch

00:23:30.780 --> 00:23:32.980
zu bekommen, ja. Also ihr braucht gute Admins

00:23:32.980 --> 00:23:35.080
für den Start, damit das funktioniert. Ähm,

00:23:35.860 --> 00:23:36.080
ja.

00:23:36.620 --> 00:23:38.840
Ja, also, okay, ein bisschen Syntax haben wir gemacht, ja,

00:23:38.900 --> 00:23:40.680
also die Frage wäre jetzt noch, was gehört als zu

00:23:40.680 --> 00:23:42.860
Python Fullstack dann? Also wenn man jetzt schon

00:23:42.860 --> 00:23:44.660
ganz viel kann und so, was würdest du sagen, wenn man richtig

00:23:44.660 --> 00:23:46.780
Fullstack entwickelt? Ja, Fullstack, ja, das ist so

00:23:46.780 --> 00:23:48.720
ein Ding, was heutzutage auch wieder, äh, in aller

00:23:48.720 --> 00:23:50.880
Munde ist, wobei das auch selten tatsächlich

00:23:50.880 --> 00:23:51.620
so ist.

00:23:52.700 --> 00:23:54.640
Würde ich sogar sagen, auch, das ist auch das, ich mach das nicht,

00:23:54.760 --> 00:23:56.700
eigentlich, ich bin deutlich eher auf der Backend-Seite

00:23:56.700 --> 00:23:58.680
als auf der Frontend-Seite, aber

00:23:58.680 --> 00:24:00.640
Fullstack hieße ja, dass du quasi alles

00:24:00.640 --> 00:24:02.600
machen kannst, von unten bis, äh,

00:24:02.720 --> 00:24:04.180
also Frontend. Also Fullstack in Python geht gar nicht, weil

00:24:04.180 --> 00:24:06.440
das geht nicht richtig, genau, weil du mit Frontend

00:24:06.440 --> 00:24:08.640
bist du halt nicht, äh, da brauchst du

00:24:08.640 --> 00:24:09.820
halt dann schon JavaScript für

00:24:09.820 --> 00:24:12.120
und, ähm, ja, oder

00:24:12.120 --> 00:24:14.640
es ginge theoretisch auch, aber das ist halt ein

00:24:14.640 --> 00:24:16.620
Bereich, der schön wäre, wenn das mit Python funktionieren

00:24:16.620 --> 00:24:18.560
würde, aber momentan geht das nicht richtig, also

00:24:18.560 --> 00:24:20.540
man konnte natürlich Python auch irgendwie Richtung

00:24:20.540 --> 00:24:22.640
WebAssembly kompilieren und dann

00:24:22.640 --> 00:24:24.720
halt im Frontend verwenden, aber es gibt keine,

00:24:25.240 --> 00:24:26.620
es gibt, ähm, eben nicht

00:24:26.620 --> 00:24:28.060
so viel wie für JavaScript, die ganzen

00:24:28.060 --> 00:24:30.680
UI-Bibliotheken, die man da so braucht, um halt

00:24:30.680 --> 00:24:32.640
Dinge irgendwie auszumachen, also

00:24:32.640 --> 00:24:34.060
schwierig.

00:24:34.980 --> 00:24:36.600
Ja, okay. Ja, das heißt,

00:24:36.640 --> 00:24:38.440
JavaScript braucht ihr, wenn ihr Fullstack machen wollt, und wenn du

00:24:38.440 --> 00:24:40.560
Python kriegst, dann kannst du hin. Aber ja, vielleicht

00:24:40.560 --> 00:24:42.620
wollt ihr das ja auch gar nicht so machen, weil, warum sollte man

00:24:42.620 --> 00:24:44.700
Fullstack machen, wenn man sich andere Sachen wie Data und

00:24:44.700 --> 00:24:46.540
Backend so gut kennt? Naja, also, wenn du eine Webseite

00:24:46.540 --> 00:24:48.460
machst, hast du halt sofort diesen ganzen

00:24:48.460 --> 00:24:50.460
Kram, wobei du da möglicherweise eben auch ohne

00:24:50.460 --> 00:24:52.400
JavaScript oder ohne viel JavaScript

00:24:52.400 --> 00:24:54.620
auskommen kannst. So eine ganz

00:24:54.620 --> 00:24:56.720
stinknormale Webseite

00:24:56.720 --> 00:24:58.240
so. Hätte man ein bisschen

00:24:58.240 --> 00:25:00.240
CSS-Forschung machen oder sowas, ja.

00:25:00.240 --> 00:25:01.260
Ja, okay. Auch kein Python.

00:25:01.800 --> 00:25:04.460
Auch wieder kein Python, genau. Aber das geht natürlich

00:25:04.460 --> 00:25:06.240
auch immer noch und ist eigentlich auch für viele

00:25:06.240 --> 00:25:08.420
Anwendungen irgendwie gar nicht so

00:25:08.420 --> 00:25:10.260
schlecht. Aber, ja.

00:25:10.560 --> 00:25:11.740
Ja, gibt ja so ein paar Framework, ne?

00:25:11.940 --> 00:25:13.540
Grid, Materialize und so.

00:25:14.520 --> 00:25:15.520
Naja, also ohne JavaScript.

00:25:15.640 --> 00:25:16.460
Aber das ist ja was anderes. Ja,

00:25:16.540 --> 00:25:18.300
Fullstack geht gar nicht ohne Python.

00:25:18.700 --> 00:25:20.680
Ja, und das ist tatsächlich

00:25:20.680 --> 00:25:21.620
auch einer der großen

00:25:21.620 --> 00:25:24.500
Risiken irgendwie für die Zukunft von

00:25:24.500 --> 00:25:25.900
Python, wenn das halt, wenn das

00:25:25.900 --> 00:25:28.440
quasi so aus dem Wettding, weil die Frage

00:25:28.440 --> 00:25:30.480
ist jetzt, kommt Python nochmal ins Frontend

00:25:30.480 --> 00:25:32.600
oder geht JavaScript

00:25:32.600 --> 00:25:34.520
ins Backend? Und wenn der Weg

00:25:34.520 --> 00:25:36.260
in die Zukunft so aussieht, dass wir dann JavaScript,

00:25:36.500 --> 00:25:38.240
weil das natürlich auch gewisse Vorteile bringt, du kannst

00:25:38.240 --> 00:25:40.260
was halt, dann schreibst du einmal den Code, kannst den

00:25:40.260 --> 00:25:42.520
im Backend und im Frontend verwenden.

00:25:43.580 --> 00:25:44.540
Wenn wir jetzt auch

00:25:44.540 --> 00:25:46.280
im Backend zunehmend JavaScript kriegen,

00:25:46.280 --> 00:25:48.200
dann brauchst du halt eigentlich Python

00:25:48.200 --> 00:25:50.100
in der Webentwicklung gar nicht mehr. Oder?

00:25:50.380 --> 00:25:52.280
Es läuft umgekehrt. Und

00:25:52.280 --> 00:25:54.100
wir kriegen auch irgendwann Python im Frontend.

00:25:54.160 --> 00:25:55.540
Das wäre natürlich eigentlich die schönere Variante.

00:25:55.760 --> 00:25:57.600
Ja, da müssen wir mal dran arbeiten, dass das passiert.

00:25:57.860 --> 00:25:57.980
Ja.

00:25:59.900 --> 00:26:01.940
Ich glaube, also die Chance ist gar nicht so schlecht. Also ich glaube,

00:26:02.280 --> 00:26:04.120
Python ist noch bei Anfängern

00:26:04.120 --> 00:26:05.760
gerade ein bisschen beliebter. Vielleicht bedeutet das, dass

00:26:05.760 --> 00:26:07.780
das irgendwann dann auch in diese Richtung driftet.

00:26:08.820 --> 00:26:09.820
Ja, mal schauen.

00:26:10.260 --> 00:26:11.620
Wer weiß. Ja,

00:26:12.120 --> 00:26:13.000
Import Sys?

00:26:13.520 --> 00:26:15.000
Import Sys, Sun of Python.

00:26:15.120 --> 00:26:16.240
Ja, ich glaube, das hatten wir letztes Jahr auch schon,

00:26:16.280 --> 00:26:17.740
mal ziemlich genau um diese

00:26:17.740 --> 00:26:20.240
Zeit. Hatten wir das nicht in der ersten Folge schon mal?

00:26:20.300 --> 00:26:21.200
Am Schluss, glaube ich, ja.

00:26:22.920 --> 00:26:24.260
Aber kann man sich auf jeden Fall immer

00:26:24.260 --> 00:26:26.400
mal wieder angucken. Ja, also den Interpreter öffnen,

00:26:26.480 --> 00:26:28.000
einfach Import Sys eingeben und

00:26:28.000 --> 00:26:30.140
abschicken und dann seht ihr das. Sun of Python,

00:26:30.240 --> 00:26:31.740
also die Prinzipien, die man

00:26:31.740 --> 00:26:34.260
sich drauf geeinigt hat, die in Python gelten,

00:26:34.400 --> 00:26:35.640
sollen auch sein.

00:26:35.760 --> 00:26:38.360
Da ist auch immer so ein bisschen Humor mit dabei.

00:26:39.380 --> 00:26:40.080
Aber ja,

00:26:40.160 --> 00:26:42.100
ist auch was dran. Ja, also das ist direkt

00:26:42.100 --> 00:26:44.260
verknüpft zu PEP 8. Ich glaube, das hatten wir dann auch schon mal kurz

00:26:44.260 --> 00:26:45.760
erwähnt, aber an der Stelle vielleicht nochmal.

00:26:46.280 --> 00:26:47.980
Einfach nur die Art, wie man

00:26:47.980 --> 00:26:50.320
relativ minimalistischer

00:26:50.320 --> 00:26:52.900
Konsens

00:26:52.900 --> 00:26:54.200
darüber, wie man Python-Code

00:26:54.200 --> 00:26:55.920
formatieren sollte, vielleicht.

00:26:57.040 --> 00:26:58.320
Und wer macht das nicht, dann

00:26:58.320 --> 00:26:59.660
kommt ihr in die Python-Höhe. Ja,

00:27:00.100 --> 00:27:02.220
aber auch innerhalb von PEP 8 gibt es ja so

00:27:02.220 --> 00:27:03.800
Dinge, die dann nicht geklärt sind dadurch.

00:27:04.820 --> 00:27:05.020
Und

00:27:05.020 --> 00:27:08.440
Black hat halt zum Beispiel eben eine Meinung

00:27:08.440 --> 00:27:09.320
dazu, wie das sein soll.

00:27:09.480 --> 00:27:12.040
Das ist bei einigen Sachen total furchtbar. Das sieht

00:27:12.040 --> 00:27:14.120
scheußlich aus. Okay, was denn?

00:27:14.740 --> 00:27:16.260
Ja, wenn ich zum Beispiel Argumente,

00:27:16.280 --> 00:27:18.400
in Funktionen packe oder

00:27:18.400 --> 00:27:20.460
längere Print-Statements schreibe,

00:27:21.240 --> 00:27:22.240
wie er die dann umbricht,

00:27:22.460 --> 00:27:24.400
dann macht er die Klammer auf

00:27:24.400 --> 00:27:26.320
in eine Zeile, dann nächste Zeile den

00:27:26.320 --> 00:27:28.360
String aus dem Print-Statement und dann da drunter

00:27:28.360 --> 00:27:30.420
die Klammer wieder zu, wo ich

00:27:30.420 --> 00:27:31.800
dann sagen würde, hey, für die fünf Zeilen,

00:27:31.920 --> 00:27:34.480
wenn das Print-Statement eh länger als 89 Zeichen ist,

00:27:34.840 --> 00:27:36.200
hättest du das auch einfach in eine Zeile schreiben können.

00:27:36.520 --> 00:27:38.360
Oder halt, wenn Kommentare am Ende der

00:27:38.360 --> 00:27:40.340
Zeile sind, dann bricht er dann trotzdem

00:27:40.340 --> 00:27:42.360
die ganze Funktion auseinander, obwohl sie noch reinpassen würde.

00:27:43.000 --> 00:27:43.900
Oder wenn

00:27:44.900 --> 00:27:45.780
Black sagt,

00:27:46.280 --> 00:27:47.800
ganz viele Argumente in einer Funktion,

00:27:48.160 --> 00:27:49.960
bricht das dann aber um, weil es nicht genug Argumente sind,

00:27:50.060 --> 00:27:52.180
um auf jeder Zeile ein Argument zu haben.

00:27:52.900 --> 00:27:54.300
Das sieht auch ganz furchtbar aus.

00:27:54.460 --> 00:27:56.100
Und dann ist dann die Klammer zu mit dem

00:27:56.100 --> 00:27:58.160
Doppelpunkt dann am Anfang von einer

00:27:58.160 --> 00:28:00.140
Zeile irgendwie drei Zeilen

00:28:00.140 --> 00:28:02.060
Funktionsdefinition. Das finde ich

00:28:02.060 --> 00:28:04.020
total furchtbar. Ich bin eh nicht

00:28:04.020 --> 00:28:05.600
so ein Freund von diesen 89 Zeichen

00:28:05.600 --> 00:28:07.740
Editor-Quatsch, weil ganz ehrlich,

00:28:08.860 --> 00:28:10.060
so entziehen, dass wir

00:28:10.060 --> 00:28:11.400
nur 89 Zeichen auf dem Bildschirm haben.

00:28:11.620 --> 00:28:13.660
79. Ja, 79. Entschuldigung.

00:28:13.900 --> 00:28:15.680
Ich entwickle nicht die ganze Zeit mit meinem Telefon.

00:28:16.280 --> 00:28:17.920
Nee, das ist für Konsolen eigentlich.

00:28:19.240 --> 00:28:20.120
Die haben halt bloß

00:28:20.120 --> 00:28:22.460
80 Zeilen, also 24 Zeilen,

00:28:22.580 --> 00:28:23.080
80

00:28:23.080 --> 00:28:25.080
Spalten.

00:28:26.440 --> 00:28:28.020
Und es gibt natürlich,

00:28:28.160 --> 00:28:30.000
oder ich weiß nicht... Ja, die alten aber nur.

00:28:30.180 --> 00:28:30.460
Also die neuen.

00:28:31.900 --> 00:28:33.860
Weiß ich nicht, ob es dann... Nee, nee, der Standard ist immer noch so.

00:28:34.500 --> 00:28:35.600
Es ist auch so, wenn du

00:28:35.600 --> 00:28:37.940
jetzt auf dem Linux oder so bist, dann hast du ja nicht unbedingt immer

00:28:37.940 --> 00:28:40.200
ein grafisches System und deine Konsole sieht halt so aus.

00:28:40.300 --> 00:28:41.880
Da gibt es keinen...

00:28:41.880 --> 00:28:43.280
Ja, aber auch bei VI hast du ja mehr.

00:28:43.280 --> 00:28:43.960
Ja, zum Beispiel.

00:28:44.660 --> 00:28:45.600
Auf einer Konsole?

00:28:46.280 --> 00:28:46.600
Ja.

00:28:50.520 --> 00:28:51.520
Also ohne grafische

00:28:51.520 --> 00:28:52.880
Benutzeroberfläche, glaube ich, ist schwierig.

00:28:53.000 --> 00:28:55.480
Aber auf der anderen Seite wahrscheinlich gibt es diesen Fall,

00:28:55.840 --> 00:28:57.600
dass jemand an einem Rechner ohne grafische Benutzeroberfläche

00:28:57.600 --> 00:28:58.660
sitzt, praktisch gar nicht mehr so.

00:28:58.680 --> 00:29:01.020
Also wenn ich mich auf meinen Server einlogge, habe ich da mehr als

00:29:01.020 --> 00:29:03.260
80 über die Konsole.

00:29:04.680 --> 00:29:05.520
Hast du dich mal an eine Konsole

00:29:05.520 --> 00:29:07.320
gestellt, an einem Rechner zu drum, an eine serielle

00:29:07.320 --> 00:29:09.420
Konsole? Ich glaube, da hast du

00:29:09.420 --> 00:29:11.400
genau die 80 Spalten

00:29:11.400 --> 00:29:12.740
und 24...

00:29:12.740 --> 00:29:13.800
Das ist ja uralt, DOS.

00:29:13.800 --> 00:29:16.140
Ja, bei DOS war das auch so, genau.

00:29:16.280 --> 00:29:16.640
Ja.

00:29:18.220 --> 00:29:18.500
Ja.

00:29:19.320 --> 00:29:20.120
Ich weiß gar nicht.

00:29:21.120 --> 00:29:23.400
Also ich glaube auch nicht, das ist eigentlich nicht mehr relevant, aber

00:29:23.400 --> 00:29:25.360
da kommt das halt her und...

00:29:25.360 --> 00:29:27.520
Wenn, dann sieht man da halt, muss man kurz darauf aufpassen,

00:29:27.600 --> 00:29:29.220
dass es dann umgebrochene Zeilen gibt.

00:29:29.800 --> 00:29:31.820
Die automatisch vielleicht eingeguckt werden oder so.

00:29:32.120 --> 00:29:33.840
Ich weiß gar nicht, auf was ich es gestellt habe

00:29:33.840 --> 00:29:35.700
bei mir. Das ist ja auch ein Ding, das man bei Black

00:29:35.700 --> 00:29:37.860
tatsächlich einstellen kann. Also da...

00:29:37.860 --> 00:29:39.680
Das muss man nicht so

00:29:39.680 --> 00:29:41.180
auf 79 zeichnen lassen.

00:29:41.560 --> 00:29:43.680
Also 79 zeichnen deswegen, weil man halt noch eins braucht

00:29:43.680 --> 00:29:44.120
von der Zeilung.

00:29:46.280 --> 00:29:47.800
Ja. Aber...

00:29:47.800 --> 00:29:49.300
Wenn...

00:29:49.300 --> 00:29:51.240
Also ich glaube, ich habe es auch nur auf einer 10 stehen.

00:29:51.300 --> 00:29:52.020
Ich weiß es nicht.

00:29:52.880 --> 00:29:55.080
Jedenfalls, das kann man ja konfigurieren und dann ist es nicht mehr so schlimm.

00:29:55.320 --> 00:29:56.960
Also ich finde auch, ein bisschen mehr als 80 geht schon.

00:29:57.720 --> 00:29:59.520
Irgendwann ist es natürlich auch wieder doof, wenn das halt zu lang wird.

00:29:59.520 --> 00:30:00.100
Ja, gut.

00:30:00.880 --> 00:30:03.060
Also so, dass man es halt vernünftig auf einem normalen Arbeitsrechner

00:30:03.060 --> 00:30:05.200
irgendwie von sich an lesen kann, dass es nicht immer halb so groß ist,

00:30:05.240 --> 00:30:07.200
dass man viel zu viel Platz braucht. Das wäre ja völlig unheimlich

00:30:07.200 --> 00:30:08.240
und hässlich, einige Sachen.

00:30:08.720 --> 00:30:11.520
Also ich finde, Black ist dann so ein bisschen inkonsistent, wenn es halt dann...

00:30:12.320 --> 00:30:13.720
Beispielsweise, du hast drei Debug-Statements

00:30:13.720 --> 00:30:15.600
hintereinander. Das eine ist vier Zeichen zu lang,

00:30:15.600 --> 00:30:17.540
dann bricht der jetzt ganz komisch rum, irgendwie

00:30:17.540 --> 00:30:18.800
und die anderen darunter

00:30:18.800 --> 00:30:21.280
sehen nicht so aus. Das ist irgendwie

00:30:21.280 --> 00:30:22.380
komisch. Naja.

00:30:23.640 --> 00:30:25.680
Also ich finde, mein ästhetisches

00:30:25.680 --> 00:30:27.000
Empfinden wird da immer so ein bisschen angehört.

00:30:27.340 --> 00:30:27.680
Naja, gut.

00:30:30.160 --> 00:30:31.880
Wann ist man Amnesie-Syndrom erkrankt?

00:30:32.740 --> 00:30:32.880
Ah.

00:30:33.820 --> 00:30:35.260
Not invented hier, ja.

00:30:36.700 --> 00:30:37.180
Das...

00:30:37.180 --> 00:30:40.620
Ja, ja, ja.

00:30:40.980 --> 00:30:42.280
Wenn man alles selber macht.

00:30:42.280 --> 00:30:44.100
Sehr böse erwischt.

00:30:44.580 --> 00:30:45.420
Ja, das ist halt das

00:30:45.420 --> 00:30:47.580
Problem. Genau, das heißt einfach nur,

00:30:48.180 --> 00:30:49.860
dass man halt versucht, alles selber zu machen

00:30:49.860 --> 00:30:51.760
und wenn es halt nicht von hier kommt,

00:30:51.880 --> 00:30:54.140
viele Firmen haben das auch, die ja alles

00:30:54.140 --> 00:30:56.140
doof finden, was sie nicht selber gemacht haben und dann

00:30:56.140 --> 00:30:58.160
halt viel zu viel selber machen. Das ist natürlich ein Problem.

00:30:58.200 --> 00:30:59.820
Wir entfinden das Rad nochmal von vorn.

00:31:00.060 --> 00:31:00.300
Genau.

00:31:00.580 --> 00:31:02.160
Das ist halt immer nett, da kann man immer was damit lernen.

00:31:02.420 --> 00:31:04.300
Also die Grundlagen zu verstehen, das kann ich so schlecht.

00:31:04.420 --> 00:31:07.060
Und hat man irgendwann nicht, kein mehr, der versteht,

00:31:07.100 --> 00:31:08.140
wie es irgendwann mal gebaut worden ist,

00:31:08.560 --> 00:31:10.640
so nur noch Leute, die dann irgendwie auf dem Sand

00:31:10.640 --> 00:31:12.500
und der Asche von alten versunkenen Städten

00:31:12.500 --> 00:31:13.640
versuchen, neue Gebäude zu errichten.

00:31:14.060 --> 00:31:15.340
Und dann immer so, oh, da war eine Grube.

00:31:15.420 --> 00:31:18.020
Oder ein Schützerpalast zusammen.

00:31:18.100 --> 00:31:19.740
Das ist natürlich dann das, was man vielleicht verhindern will.

00:31:19.780 --> 00:31:21.780
Und deswegen ist das vielleicht auch gar nicht immer so schlecht.

00:31:22.240 --> 00:31:24.000
Aber natürlich kann man ja viel Zeit damit verschwinden,

00:31:24.380 --> 00:31:25.620
dass man einfach anfängt, komplett

00:31:25.620 --> 00:31:27.580
das Rad nochmal neu zu erfinden,

00:31:27.680 --> 00:31:29.140
obwohl man eigentlich schon irgendwie fliegen könnte.

00:31:29.440 --> 00:31:31.420
Ja, es ist

00:31:31.420 --> 00:31:33.460
immer schwierig. Man muss halt eine richtige

00:31:33.460 --> 00:31:35.060
Balance finden. Es ist manchmal gut,

00:31:36.760 --> 00:31:37.860
also ein Beispiel dafür wäre

00:31:37.860 --> 00:31:39.680
auch dieses Timestamp-Modell

00:31:39.680 --> 00:31:42.140
aus den Model-Utils. Deswegen haben alle als Abhängigkeit

00:31:42.140 --> 00:31:43.400
Model-Utils drin.

00:31:44.400 --> 00:31:45.360
Dabei, ja,

00:31:45.420 --> 00:31:47.320
da hat es dann auch so,

00:31:47.920 --> 00:31:49.300
wie meinte ich, Jango 3 kurz

00:31:49.300 --> 00:31:51.980
auch gesprochen

00:31:51.980 --> 00:31:53.800
und da hat er dann so,

00:31:53.840 --> 00:31:55.340
naja, das sind halt eigentlich zwei Zeilen

00:31:55.340 --> 00:31:57.960
irgendwie in einem Modell, wenn man das selber

00:31:57.960 --> 00:31:58.220
macht.

00:31:59.740 --> 00:32:01.980
Vielleicht wäre es besser gewesen, die beiden Zeilen dann selber

00:32:01.980 --> 00:32:04.040
hinzuschreiben und dann diese Abhängigkeit

00:32:04.040 --> 00:32:05.860
nicht zu haben, weil jetzt hat man halt das Problem,

00:32:06.080 --> 00:32:08.000
dass wenn man, das ist ja auch wieder

00:32:08.000 --> 00:32:09.080
blöd, wenn man nichts selber macht.

00:32:09.660 --> 00:32:12.240
Ganz schlimm, NPM hat das ja auch so bei JavaScript-Geschichten.

00:32:12.940 --> 00:32:13.880
Dann hast du halt,

00:32:13.880 --> 00:32:16.620
musst du dich halt viel mit dieser

00:32:16.620 --> 00:32:18.820
Maintenance von diesem Kram beschäftigen,

00:32:18.940 --> 00:32:19.840
was ja auch blöd ist.

00:32:20.040 --> 00:32:22.560
Ja, Paketversionierung muss immer stimmen und genau

00:32:22.560 --> 00:32:24.600
dem Stufstand bleiben und wenn du dann irgendwelche

00:32:24.600 --> 00:32:26.940
Bugs hast, musst du dann irgendwas updaten, weil irgendwas kritisch war

00:32:26.940 --> 00:32:28.680
und das hat dann andere Abhängigkeiten

00:32:28.680 --> 00:32:30.760
und dann fliegt dir irgendwas auseinander, weil das inkompatibel

00:32:30.760 --> 00:32:31.960
ist mit irgendeiner neuen Implementierung.

00:32:33.260 --> 00:32:34.380
Also es ist halt auch,

00:32:34.540 --> 00:32:36.500
man kann nicht sagen, das eine ist super schlecht, das andere ist,

00:32:36.900 --> 00:32:38.640
sondern es ist halt, man muss halt irgendwie

00:32:38.640 --> 00:32:39.260
da einen,

00:32:39.860 --> 00:32:41.540
ja,

00:32:41.960 --> 00:32:43.840
irgendwie einen Weg,

00:32:43.880 --> 00:32:46.000
finden, der für den Anwendungsfall,

00:32:46.040 --> 00:32:47.460
den man hat, den besten Trade-Off bietet.

00:32:49.060 --> 00:32:50.080
Aber tatsächlich

00:32:50.080 --> 00:32:51.600
ist es so, dass die meisten Leute eher

00:32:51.600 --> 00:32:53.900
zu viel Richtung Not-Invented

00:32:53.900 --> 00:32:54.220
hier gehen.

00:32:55.960 --> 00:32:57.720
Ja, manchmal ist das praktisch.

00:32:57.760 --> 00:32:59.700
Ich glaube, manchmal ist es auch gar nicht so schlecht, wenn man einfach coole Sachen,

00:32:59.820 --> 00:33:01.360
die cool funktionieren, einfach benutzen kann und die dann

00:33:01.360 --> 00:33:04.000
cool weiter funktionieren und dann auch einem schnell

00:33:04.000 --> 00:33:05.520
irgendwas ermöglichen zu entwickeln.

00:33:05.880 --> 00:33:07.800
Ich glaube, gerade für Anfänger ist das gar nicht so schlecht, wenn man halt nicht

00:33:07.800 --> 00:33:09.880
von ganz immer anfängt, obwohl es natürlich auch

00:33:09.880 --> 00:33:11.840
nett ist, wenn man vielleicht erstmal Assembler lernt und dann

00:33:11.840 --> 00:33:13.660
C und dann irgendwie guckt, wie es alles so funktioniert.

00:33:13.880 --> 00:33:15.600
Aber es ist auch vielleicht ein bisschen aufwendig.

00:33:15.700 --> 00:33:17.860
Man kann vielleicht auch ab und zu mal eine High-Level-Bibliothek

00:33:17.860 --> 00:33:19.840
einfach benutzen, um zu gucken, wie man Dinge

00:33:19.840 --> 00:33:21.760
damit anstellt, ohne direkt alles zu

00:33:21.760 --> 00:33:23.120
verstehen oder selber zu implementieren.

00:33:23.460 --> 00:33:25.800
Ja, über die Zeit ist es natürlich

00:33:25.800 --> 00:33:27.760
so, dass auch der Level an

00:33:27.760 --> 00:33:29.380
Abstraktion, auf dem man arbeitet, ist halt

00:33:29.380 --> 00:33:31.800
immer höher eigentlich, weil halt immer mehr

00:33:31.800 --> 00:33:33.920
wird Commodity, also die Sachen, die früher

00:33:33.920 --> 00:33:37.680
der interessante Bereich waren, in dem man irgendwas

00:33:37.680 --> 00:33:39.100
gemacht hat, die werden halt zunehmend

00:33:39.100 --> 00:33:41.620
Community und wandern halt

00:33:41.620 --> 00:33:43.860
sozusagen aus dem interessanten Feld raus.

00:33:43.880 --> 00:33:45.860
Und das, wo man

00:33:45.860 --> 00:33:47.820
die interessanten Sachen machen kann, das

00:33:47.820 --> 00:33:49.680
geht über die Zeit immer in abstrakter

00:33:49.680 --> 00:33:51.700
Geschichten. Das ist halt auch die Frage, inwiefern das

00:33:51.700 --> 00:33:53.440
nicht unter Umständen...

00:33:53.440 --> 00:33:55.740
Auf der einen Seite kann man sagen, man kann heute

00:33:55.740 --> 00:33:57.660
mit viel weniger Zeilencode

00:33:57.660 --> 00:33:59.260
viel kompliziertere Dinge und

00:33:59.260 --> 00:34:01.600
tollere Sachen bauen. Auf der anderen Seite ist es halt, wenn man

00:34:01.600 --> 00:34:03.180
sich das manchmal genauer anguckt, ist halt

00:34:03.180 --> 00:34:05.380
steht das alles so ein bisschen auf

00:34:05.380 --> 00:34:07.620
tönernen Füßen. Das ist halt so Kartenhaus über

00:34:07.620 --> 00:34:08.580
Kartenhaus-Geschichte.

00:34:09.300 --> 00:34:11.500
Auf den unteren Ebenen stimmen schon viele Sachen

00:34:11.500 --> 00:34:13.440
nicht mehr so richtig, aber dann baut man halt so lange

00:34:13.440 --> 00:34:15.680
Abstraktionen drüber, bis es wieder...

00:34:15.680 --> 00:34:17.300
Aber in Wirklichkeit

00:34:17.300 --> 00:34:19.440
hat man diese Probleme nicht wirklich gelöst.

00:34:19.460 --> 00:34:21.400
Wenn man halt das Gebäude und den Palast auf der Samtgrube baut,

00:34:21.460 --> 00:34:23.600
man kann tatsächlich noch ein paar Stahlträger einziehen, das dann zu tun

00:34:23.600 --> 00:34:24.760
könnte, der Palast zu gehalten.

00:34:24.940 --> 00:34:27.140
Das ist halt dann...

00:34:27.140 --> 00:34:28.320
Ja.

00:34:29.800 --> 00:34:31.480
Aha. Ja, aber jetzt gehen wir, glaube ich,

00:34:31.480 --> 00:34:33.420
jetzt haben wir so ein bisschen generell darüber gesprochen, was

00:34:33.420 --> 00:34:35.400
so Python generell

00:34:35.400 --> 00:34:37.460
ausmacht. Jetzt gehen wir so ein bisschen tiefer

00:34:37.460 --> 00:34:39.600
in die Probleme der...

00:34:39.600 --> 00:34:41.580
Oder was heißt die Probleme? Die Ideen, die Konzepte

00:34:41.580 --> 00:34:43.360
der eigentlichen Sprache, was man auch vielleicht

00:34:43.360 --> 00:34:45.500
achten muss. Also, falls ihr noch Fragen habt, die ich nicht beantwortet hatte,

00:34:45.620 --> 00:34:46.540
schreibt uns wieder, wie immer.

00:34:47.080 --> 00:34:48.120
Hallo, AppPython Podcast.

00:34:49.440 --> 00:34:50.320
Wofür ist die InetPy?

00:34:53.140 --> 00:34:55.420
Das ist eine gute Frage. Ja, man braucht das

00:34:55.420 --> 00:34:55.880
irgendwie,

00:34:56.220 --> 00:34:58.680
damit es ein Paket ist.

00:35:00.820 --> 00:35:01.540
Ein Modul?

00:35:01.740 --> 00:35:03.500
Wo ist der Unterschied zwischen Modul und Paket? Oh mein Gott.

00:35:03.880 --> 00:35:05.540
Ich glaube, das muss ich ja selber nochmal nachlesen.

00:35:05.940 --> 00:35:07.300
Damit der Namespace irgendwie

00:35:07.300 --> 00:35:09.260
vernünftig zugegriffen werden kann. Also alles, was man da irgendwie

00:35:09.260 --> 00:35:11.500
reinpackt, das sitzt dann im Namespace dieses Moduls,

00:35:11.500 --> 00:35:12.880
wenn man es importiert, direkt drin.

00:35:13.360 --> 00:35:15.220
Mhm. Irgendwie so. Und dann kann man da direkt

00:35:15.220 --> 00:35:17.640
aktiv drauf zugreifen. Aber die Frage ist halt,

00:35:17.680 --> 00:35:19.340
warum man das dann nicht mit den Submodulen macht.

00:35:19.940 --> 00:35:20.800
Nee, du kannst das ja auch

00:35:20.800 --> 00:35:23.560
reinschreiben,

00:35:23.820 --> 00:35:25.940
was du exportieren willst, welche Symbole.

00:35:27.880 --> 00:35:29.500
Interessant ist, kann man da auch Sachen ausschließen?

00:35:29.780 --> 00:35:31.380
Also, dass ich zum Beispiel sage, ja, aber diesen Modul

00:35:31.380 --> 00:35:33.620
bitte nicht in den Namespace packen oder sowas?

00:35:35.600 --> 00:35:37.520
Also, es kommt noch eine andere Frage von einem Hörer von uns,

00:35:37.660 --> 00:35:39.580
der wissen wollte, wie das dann überhaupt so funktioniert,

00:35:39.580 --> 00:35:41.620
dass man Module selber bauen kann. Ich glaube, das Einzige,

00:35:41.720 --> 00:35:43.280
was man machen muss, ist halt ein Folder,

00:35:43.360 --> 00:35:45.180
importieren. Also, indem man halt

00:35:45.180 --> 00:35:46.760
relativ einen Zugriff drauf hat.

00:35:47.140 --> 00:35:48.560
Und dann einfach sagen, import

00:35:48.560 --> 00:35:51.140
Foldername oder sowas. Und wenn da eine

00:35:51.140 --> 00:35:53.360
InitPy drin ist, dann kann man die Module,

00:35:53.460 --> 00:35:54.800
die da drin sind, einfach aufrufen.

00:35:55.660 --> 00:35:57.100
Mit einem Import-Teil. Und dann kann man

00:35:57.100 --> 00:35:59.180
from Modul Verzeichnisname

00:35:59.180 --> 00:36:01.040
import Python-Datei oder

00:36:01.040 --> 00:36:03.920
from Modulname Punkt Python-Datei

00:36:03.920 --> 00:36:05.000
import Funktionsname.

00:36:05.440 --> 00:36:06.880
Und dann kann man die

00:36:06.880 --> 00:36:09.220
einsetzen auf dieser lokalen Ebene.

00:36:09.220 --> 00:36:11.040
Und die Frage wäre halt jetzt, warum man diese

00:36:11.040 --> 00:36:13.200
InitPy an der Stelle braucht und was die halt

00:36:13.200 --> 00:36:15.120
vielleicht macht. Und dass sie vielleicht

00:36:15.120 --> 00:36:17.040
halt dieses Namespacing, was in Python auch

00:36:17.040 --> 00:36:19.220
irgendwie so ein Ding ist. Also, zum Beispiel zu sagen,

00:36:19.560 --> 00:36:21.500
welcher Name jetzt zu welcher Funktion,

00:36:21.620 --> 00:36:23.440
zu welcher Sublibrary gehört,

00:36:24.080 --> 00:36:25.100
dass das da ein bisschen

00:36:25.100 --> 00:36:27.460
definiert wird. Ja, man kann auf jeden Fall

00:36:27.460 --> 00:36:29.320
an der Stelle kontrollieren, was

00:36:29.320 --> 00:36:30.920
halt eben,

00:36:31.620 --> 00:36:33.220
was mit welchem Namen exportiert werden

00:36:33.220 --> 00:36:35.040
soll, sozusagen. Und

00:36:35.040 --> 00:36:37.220
dafür ist es ganz

00:36:37.220 --> 00:36:39.060
nützlich. Warum man sie unbedingt braucht, weiß ich nicht so genau.

00:36:39.160 --> 00:36:40.160
Und das ist auch etwas, was

00:36:40.160 --> 00:36:43.120
mir schon öfter mal auf den Fuß gefallen ist und wahrscheinlich

00:36:43.120 --> 00:36:45.240
vielen Leuten, die jetzt, dass man

00:36:45.240 --> 00:36:47.140
halt, kriegt manchmal so wenig hilfreiche

00:36:47.140 --> 00:36:49.360
Fehlermeldungen, wenn man die InitPy

00:36:49.360 --> 00:36:50.920
vergisst, sozusagen.

00:36:51.060 --> 00:36:53.100
Oder wenn die aus irgendwelchen Gründen abhanden gekommen ist, was ja

00:36:53.100 --> 00:36:54.840
auch manchmal vorkommen kann. Und dann

00:36:54.840 --> 00:36:57.080
kriegt man Facebacks, die sehen irgendwie komisch

00:36:57.080 --> 00:36:59.260
aus. Und man sieht denen nicht sofort an,

00:36:59.300 --> 00:37:00.640
dass da eine InitPy fehlt.

00:37:00.940 --> 00:37:03.080
Irgendwann weiß man halt einfach so, ah, das sieht jetzt danach aus.

00:37:03.160 --> 00:37:05.140
Okay, das könnte sein, dass da einfach eine InitPy fehlt.

00:37:05.400 --> 00:37:06.980
Aber ich habe zehn Minuten da vor meinem

00:37:06.980 --> 00:37:08.920
Bildschirm gestanden und überlegt, warum macht der jetzt nicht

00:37:08.920 --> 00:37:11.200
die Migration von meinem Dankmodell, den ich da geschrieben

00:37:11.200 --> 00:37:12.980
habe? Das verstehe ich nicht. Und dann fehlte

00:37:12.980 --> 00:37:14.900
einfach die InitPy Migration-Spoiler und dann, also

00:37:14.900 --> 00:37:16.800
ach so, ja klar, kennt der ja nicht, kann der ja gar nicht sehen.

00:37:17.200 --> 00:37:19.020
Ja. Aber da muss man auch drauf kommen

00:37:19.020 --> 00:37:21.000
tatsächlich, sonst. Ja, das ist ein bisschen

00:37:21.000 --> 00:37:22.800
genau. Und

00:37:22.800 --> 00:37:24.080
eben, ja, also gute

00:37:24.080 --> 00:37:26.980
Idee mit, was

00:37:26.980 --> 00:37:28.780
sind eigentlich Paketemodule, wie

00:37:28.780 --> 00:37:30.680
funktioniert eigentlich Importsystem und so, müssen wir uns auch noch mal

00:37:30.680 --> 00:37:32.960
beschäftigen. Aber da müsste ich mich auch erstmal anlesen.

00:37:33.060 --> 00:37:34.340
Weiß ich jetzt alles gar nicht so genau.

00:37:35.160 --> 00:37:36.920
Ja, kriegen wir bestimmt noch jeden Tag. Aber wir haben

00:37:36.920 --> 00:37:38.940
ja schon die Minute schon wieder überschritten. Ah ja, gut.

00:37:39.180 --> 00:37:40.880
Ja, aber InitPy ist halt, wenn man

00:37:40.880 --> 00:37:42.800
mit dann, dann, also Doppel-Underscore am

00:37:42.800 --> 00:37:44.840
Anfang und am Ende, also wofür brauchen wir überhaupt ein Underscore

00:37:44.840 --> 00:37:45.740
und wofür zwei?

00:37:47.340 --> 00:37:48.320
Ja, also ich glaube, das ist,

00:37:49.240 --> 00:37:50.640
also die

00:37:50.640 --> 00:37:51.460
Konvention ist,

00:37:51.720 --> 00:37:54.780
ich glaube, früher war es mal nicht nur eine Konvention,

00:37:54.780 --> 00:37:56.360
aber mittlerweile ist es tatsächlich nur Konvention,

00:37:56.980 --> 00:37:57.900
dass man Sachen, die halt

00:37:57.900 --> 00:37:59.440
innerhalb einer

00:37:59.440 --> 00:38:02.320
Klasse oder innerhalb,

00:38:02.720 --> 00:38:04.480
also Dinge, die halt sozusagen

00:38:04.480 --> 00:38:06.100
private API sind oder privat

00:38:06.100 --> 00:38:08.080
benutzt werden, aber nicht nach außen,

00:38:08.800 --> 00:38:10.000
eigentlich nicht von außen

00:38:10.000 --> 00:38:12.760
benutzt, also angefasst

00:38:12.760 --> 00:38:14.620
werden sollten, die werden

00:38:14.620 --> 00:38:16.840
halt mit Doppel-Underscore

00:38:16.840 --> 00:38:18.180
halt irgendwie gepräfixt

00:38:18.180 --> 00:38:20.840
und Sachen, die halt sozusagen

00:38:20.840 --> 00:38:22.740
dann gibt es

00:38:22.740 --> 00:38:24.560
einfach ein Underscore, das ist halt so

00:38:24.560 --> 00:38:26.740
markiert für

00:38:26.740 --> 00:38:28.860
ja,

00:38:29.100 --> 00:38:30.800
also

00:38:30.800 --> 00:38:32.760
kann, ist auch, sollte man

00:38:32.760 --> 00:38:34.640
nicht, sollte man nicht, ist auch eher so

00:38:34.640 --> 00:38:36.640
interner Gebrauch, ja, aber ist jetzt nicht so total

00:38:36.640 --> 00:38:37.800
privat.

00:38:40.140 --> 00:38:40.580
Ja,

00:38:40.960 --> 00:38:42.660
also ist es eine Konvention,

00:38:42.760 --> 00:38:44.720
im Grunde braucht man das auch, also

00:38:44.720 --> 00:38:45.880
außer jetzt manchmal bei

00:38:45.880 --> 00:38:49.620
bei Doppel-Underscore

00:38:49.620 --> 00:38:50.760
eigentlich auch nicht

00:38:50.760 --> 00:38:52.520
wirklich, also jedenfalls.

00:38:52.600 --> 00:38:54.580
Also ich habe zum Beispiel diese internen Variablen, habe ich noch

00:38:54.580 --> 00:38:56.780
nicht verstanden, wofür das gut ist, ich habe es auch noch nie

00:38:56.780 --> 00:38:58.560
benutzt, außer jetzt im, sag mal,

00:38:58.680 --> 00:39:00.320
im Magic-Method-Kontext von

00:39:00.320 --> 00:39:02.820
Klassen, wo man halt dann irgendwelche magischen Methoden,

00:39:02.920 --> 00:39:04.760
die es im Identitätsüberschreiben will, um andere Effekte

00:39:04.760 --> 00:39:06.660
zu erzeugen, aber...

00:39:06.660 --> 00:39:08.800
Ja, es ist halt so ein Hinweis

00:39:08.800 --> 00:39:10.700
darauf, dass man da

00:39:10.700 --> 00:39:12.700
nicht wirklich

00:39:12.700 --> 00:39:14.660
mit interagieren sollte.

00:39:14.920 --> 00:39:16.400
Nicht umfummeln, ich fasse meine Klasse nicht an.

00:39:17.180 --> 00:39:18.560
Alles, was man selber schreibt, machen immer

00:39:18.560 --> 00:39:20.380
anders vor, damit niemand anderes es macht.

00:39:21.080 --> 00:39:22.540
Nee, nee, ich versuche mal

00:39:22.540 --> 00:39:23.900
ein Beispiel zu geben, also wenn du

00:39:23.900 --> 00:39:26.180
eine Klasse hast, die irgendwas cached, dann

00:39:26.180 --> 00:39:27.200
packst du halt,

00:39:28.660 --> 00:39:30.520
wenn, also du rechnest es

00:39:30.520 --> 00:39:32.240
halt aus, du überprüfst in der Methode, ja, also

00:39:32.240 --> 00:39:34.480
ein bestimmtes Attribut ist

00:39:34.480 --> 00:39:36.400
eine Property von dieser Klasse,

00:39:36.560 --> 00:39:38.440
also hat ein Property-Dekorator drüber, irgendwas wird

00:39:38.440 --> 00:39:40.660
ausgerechnet und du schreibst

00:39:40.660 --> 00:39:42.340
das Ergebnis dieser Berechnung, also prüfst,

00:39:42.340 --> 00:39:42.540
also,

00:39:42.700 --> 00:39:44.480
wenn du die Methode aufrufst, zuerst habe ich das schon

00:39:44.480 --> 00:39:46.540
ausgerechnet, wenn ja, gibst du

00:39:46.540 --> 00:39:47.080
einfach das

00:39:47.080 --> 00:39:49.980
gecachete, den gecacheten Wert zurück

00:39:49.980 --> 00:39:52.280
und ansonsten rechnest du es halt neu aus, unter

00:39:52.280 --> 00:39:53.940
bestimmten Bedingungen.

00:39:54.320 --> 00:39:54.580
Und

00:39:54.580 --> 00:39:58.440
den Cache selber, den legt man oft

00:39:58.440 --> 00:40:00.720
dann in so einem Underscore-Attribut

00:40:00.720 --> 00:40:02.260
ab. Underscore-Cache. Ja.

00:40:02.560 --> 00:40:03.380
Oder Underscore

00:40:03.380 --> 00:40:06.460
dieser Name dieses Attributes

00:40:06.460 --> 00:40:07.380
oder so, weil,

00:40:08.180 --> 00:40:10.560
und das heißt halt ja, bitte nicht anfassen, weil das Problem

00:40:10.560 --> 00:40:12.420
ist jetzt, wenn ich von außen da rangehe, dann kriege ich vielleicht

00:40:12.420 --> 00:40:14.560
den gecacheten Wert, aber ich kenne ja jetzt gar nicht

00:40:14.560 --> 00:40:16.120
die Bedingungen, unter denen das vielleicht

00:40:16.120 --> 00:40:18.340
den Cache invalidieren müsste oder so.

00:40:18.680 --> 00:40:20.080
Und wenn ich da jetzt einfach so drauf zugreife,

00:40:20.640 --> 00:40:22.600
dann kann

00:40:22.600 --> 00:40:24.240
sein, dass Dinge schief gehen.

00:40:25.120 --> 00:40:26.480
Und das heißt,

00:40:26.860 --> 00:40:28.400
ja, das ist halt so eine Markierung für

00:40:28.400 --> 00:40:30.340
das Ding hier bitte nicht direkt verwenden,

00:40:30.520 --> 00:40:32.560
sondern, ne, dann gibt es ja meistens ein öffentliches

00:40:34.200 --> 00:40:34.700
Attribut,

00:40:34.920 --> 00:40:36.580
was man benutzen kann und dann

00:40:36.580 --> 00:40:38.560
kann die Klasse das intern handeln.

00:40:38.560 --> 00:40:40.540
Was ist denn überhaupt eine API?

00:40:42.420 --> 00:40:44.340
Ja, im Grunde

00:40:44.340 --> 00:40:46.400
eine Schnittstelle, die Schnittstelle

00:40:46.400 --> 00:40:48.440
zu irgendwas. Es gibt es jetzt

00:40:48.440 --> 00:40:49.340
auch in unterschiedlichen

00:40:49.340 --> 00:40:52.460
Kontexten kann man das verwenden,

00:40:52.680 --> 00:40:54.340
aber ich würde jetzt mal sagen, also üblicherweise,

00:40:54.440 --> 00:40:55.540
wenn man jetzt irgendein Paket

00:40:55.540 --> 00:40:57.600
verwendet,

00:40:58.040 --> 00:41:00.200
weiß ich nicht, Party-Django-Paket

00:41:00.200 --> 00:41:01.760
oder eine Python-Bibliothek oder so,

00:41:02.240 --> 00:41:04.240
dann ist die API das, was man

00:41:04.240 --> 00:41:05.840
sozusagen von außen benutzt.

00:41:06.140 --> 00:41:08.100
Die besteht ja aus ganz vielen Funktionen.

00:41:08.100 --> 00:41:10.240
Die man für seine Bibliothek benutzen kann,

00:41:10.540 --> 00:41:12.360
um die Anwendung,

00:41:12.420 --> 00:41:14.220
um damit irgendwas zu machen. Also wenn ich jetzt

00:41:14.220 --> 00:41:16.220
zum Beispiel jetzt Requests nehme oder so,

00:41:16.360 --> 00:41:18.460
dann macht request.get

00:41:18.460 --> 00:41:20.320
macht halt ein get-Request. Das ist halt der öffentliche.

00:41:20.940 --> 00:41:22.380
Intern macht das dann unter Umständen

00:41:22.380 --> 00:41:24.020
noch eine ganze Menge anderer Funktionsaufrufe

00:41:24.020 --> 00:41:25.700
und Dinge und weißer Teufel.

00:41:26.000 --> 00:41:27.980
Und die sind aber intern gar nicht alle mit

00:41:27.980 --> 00:41:30.280
einem Underscore. Nö, also manche von denen kann ich

00:41:30.280 --> 00:41:32.300
auch einfach so verwenden, das ist ja auch gar kein Problem, aber

00:41:32.300 --> 00:41:34.020
andere wahrscheinlich auch eher nicht.

00:41:34.380 --> 00:41:36.020
Und die, die ich nicht unbedingt verwenden sollte

00:41:36.020 --> 00:41:38.340
von außen, die sind halt dann so markiert

00:41:38.340 --> 00:41:40.380
als, ja, für internen Brauch.

00:41:41.400 --> 00:41:41.580
Ja.

00:41:42.420 --> 00:41:44.380
Was ist eine private und eine globale Variable

00:41:44.380 --> 00:41:46.000
und was ist der Unterschied und wofür braucht man das?

00:41:47.180 --> 00:41:48.680
Global, privat. Also privat,

00:41:48.840 --> 00:41:50.120
öffentlich, das ist halt so ein bisschen,

00:41:50.440 --> 00:41:52.540
aber das hat man in Python eigentlich auch gar nicht so

00:41:52.540 --> 00:41:54.660
wahnsinnig viel. Also es gibt in anderen Programmiersprachen

00:41:54.660 --> 00:41:56.660
gibt es da eine stärkere

00:41:56.660 --> 00:41:58.760
Unterscheidung, aber also im Grunde

00:41:58.760 --> 00:41:59.960
ist es einfach so. Also ich hatte es gerade so in den

00:41:59.960 --> 00:42:02.560
Anfängertagen ganz oft so, dass ich irgendwie mir

00:42:02.560 --> 00:42:04.460
dachte, so ja, private Variable,

00:42:04.540 --> 00:42:06.620
das ist alles irgendwie ein bisschen blöd. Ich muss ja irgendwie von einer Funktion

00:42:06.620 --> 00:42:08.660
immer irgendwie so einen Wert returnen und damit das dann,

00:42:08.780 --> 00:42:10.380
also ich glaube im Kontext einer Funktion sind ja die

00:42:10.380 --> 00:42:11.900
eigentlich die Variablen immer privat.

00:42:12.420 --> 00:42:14.440
Nein, nee, das ist nur eine Verwechslung. Also du meinst

00:42:14.440 --> 00:42:16.180
lokal, lokal und global.

00:42:16.780 --> 00:42:18.400
Privat und öffentlich,

00:42:18.500 --> 00:42:20.540
das ist halt genau diese Geschichte mit dem Double-Andersquad.

00:42:20.620 --> 00:42:22.600
Ja, okay. Dann meinte ich lokal

00:42:22.600 --> 00:42:24.180
und global, ja.

00:42:24.380 --> 00:42:26.420
Also lokal heißt, Variablen sind

00:42:26.420 --> 00:42:28.640
halt quasi in dem

00:42:28.640 --> 00:42:29.060
Block

00:42:29.060 --> 00:42:31.280
gültig.

00:42:33.280 --> 00:42:34.160
Und global.

00:42:34.700 --> 00:42:36.460
Und ich habe immer gehört, man braucht keine globale,

00:42:36.500 --> 00:42:38.240
man darf die nicht nehmen und das ist total nicht so

00:42:38.240 --> 00:42:39.340
backrested. Kann man schon.

00:42:39.900 --> 00:42:42.260
An einigen Stellen habe ich halt gemerkt, also gerade ich habe manchmal so Spiele

00:42:42.260 --> 00:42:42.400
rein,

00:42:42.420 --> 00:42:44.200
gemacht, Spiele gebaut oder sowas, da haben das

00:42:44.200 --> 00:42:46.460
total super geholfen, weil das nicht die

00:42:46.460 --> 00:42:48.100
Lebensenergie des kleinen Männchens

00:42:48.100 --> 00:42:50.340
global zu definieren, anstatt in einer Funktion

00:42:50.340 --> 00:42:52.260
oder so. Ja, ja, nee, kann

00:42:52.260 --> 00:42:54.200
man durchaus machen. Es gibt auch Fälle, wo man das

00:42:54.200 --> 00:42:55.620
durchaus

00:42:55.620 --> 00:42:58.740
praktische Anwendungsfälle

00:42:58.740 --> 00:42:58.960
hat.

00:43:00.320 --> 00:43:02.380
Ist jetzt nicht unbedingt immer so guter, also es kommt

00:43:02.380 --> 00:43:03.880
halt drauf an, was man damit machen möchte.

00:43:04.180 --> 00:43:06.400
Also man

00:43:06.400 --> 00:43:08.320
muss das halt explizit halt dann

00:43:08.320 --> 00:43:10.080
als global markieren, wenn man das tun möchte.

00:43:10.080 --> 00:43:11.780
Und dann gibt es auch noch, glaube ich, nochmal einen Unterschied zwischen

00:43:11.780 --> 00:43:13.980
nur global oder global für

00:43:13.980 --> 00:43:15.260
ein Modul oder

00:43:15.260 --> 00:43:16.780
aber

00:43:16.780 --> 00:43:20.080
ja, also für manche Sachen

00:43:20.080 --> 00:43:22.320
ist das durchaus, also gerade irgendwelche Konstanten

00:43:22.320 --> 00:43:24.280
oder so, die definiert werden, die sind oft global.

00:43:25.300 --> 00:43:26.080
Also wenn man das nicht

00:43:26.080 --> 00:43:28.000
ändert, ist das ja auch nicht schlimm. Wenn man

00:43:28.000 --> 00:43:29.820
jetzt globale Variablen hat, die man ändert,

00:43:30.000 --> 00:43:30.880
dann ist so ein bisschen

00:43:30.880 --> 00:43:33.900
das riecht dann schon so ein bisschen

00:43:33.900 --> 00:43:36.000
danach, als ob da irgendwas nicht so richtig ordentlich

00:43:36.000 --> 00:43:36.780
funktioniert, weil

00:43:36.780 --> 00:43:39.860
was

00:43:39.860 --> 00:43:41.660
möchte man damit eigentlich machen? Also man

00:43:41.780 --> 00:43:43.800
hat da irgendwie State, auf den man

00:43:43.800 --> 00:43:45.940
zugreift von unterschiedlichen Stellen, also es wird dann halt sehr schwer

00:43:45.940 --> 00:43:48.120
zu debuggen und sehr schwer vorauszusagen,

00:43:48.180 --> 00:43:49.980
was da eigentlich passiert, wenn man das einfach so verwendet

00:43:49.980 --> 00:43:51.840
und in unterschiedlichen Stellen des Codes

00:43:51.840 --> 00:43:53.880
das dann ändert, einfach so.

00:43:54.100 --> 00:43:55.840
Da muss man sich halt sehr, sehr genau überlegen

00:43:55.840 --> 00:43:57.620
oder man muss halt, also

00:43:57.620 --> 00:43:59.660
vielleicht fange ich so rum an.

00:43:59.960 --> 00:44:01.820
Das Problem beim Programmieren ist dann halt irgendwie,

00:44:01.920 --> 00:44:03.680
dass ich an der Stelle, wo ich das ändere,

00:44:04.060 --> 00:44:05.680
muss mir ja immer klar sein,

00:44:06.940 --> 00:44:07.840
was an allen anderen

00:44:07.840 --> 00:44:09.880
Stellen im Code, an dem

00:44:09.880 --> 00:44:11.760
an diesem Ding irgendwie rumgeschraubt wird, auch passiert.

00:44:11.780 --> 00:44:12.120
Warum?

00:44:13.080 --> 00:44:15.540
Also ich nehme jetzt mal so ein Beispiel, wo ich jetzt intuitiv

00:44:15.540 --> 00:44:17.620
sagen würde, das wäre jetzt für mich das, was ich

00:44:17.620 --> 00:44:19.140
jetzt als globale Variable nennen würde.

00:44:19.460 --> 00:44:21.540
Ich habe jetzt ein Spiel, mein Barbar hat

00:44:21.540 --> 00:44:23.720
Lebensenergie von 100 und es gibt

00:44:23.720 --> 00:44:25.400
bestimmte Funktionen, die aufgerufen werden, wenn

00:44:25.400 --> 00:44:27.700
der Barbar irgendwas macht, falsch macht, richtig macht,

00:44:27.780 --> 00:44:29.880
runterfällt, gegen einen anderen, gegen einen Monster kämpft,

00:44:30.340 --> 00:44:31.640
dann würde ich von dieser

00:44:31.640 --> 00:44:33.260
globalen Lebensenergie irgendwas abziehen.

00:44:34.460 --> 00:44:34.580
Ja.

00:44:35.840 --> 00:44:37.660
Wofür muss ich denn dann an der einen Stelle,

00:44:37.780 --> 00:44:39.520
wenn er jetzt, weiß ich nicht, auf ein Skelett trifft,

00:44:39.520 --> 00:44:41.580
dem 10 Lebensenergie abzieht, wissen,

00:44:41.780 --> 00:44:43.820
was an der anderen Stelle die Falle mit ihm gemacht hat?

00:44:46.520 --> 00:44:47.260
Naja, also,

00:44:47.620 --> 00:44:49.060
weil du, weil ja, naja,

00:44:49.580 --> 00:44:51.640
lass mal überlegen, kann ich irgendwas konstruieren,

00:44:51.780 --> 00:44:53.620
was dann problematisch

00:44:53.620 --> 00:44:55.400
wird? Ich meine, es kann ja auch Dinge geben, die

00:44:55.400 --> 00:44:56.520
Lebensenergie wieder erhöhen.

00:44:57.340 --> 00:44:59.040
Ein Trank. Ja, und du musst halt zum Beispiel,

00:44:59.800 --> 00:45:01.620
du musst halt wissen, dass das jetzt schon

00:45:01.620 --> 00:45:03.620
nicht unter Null gefallen ist, wenn du jetzt,

00:45:04.140 --> 00:45:05.460
sonst könntest du dich ja auch wieder

00:45:05.460 --> 00:45:06.500
lebendig machen,

00:45:07.160 --> 00:45:08.560
sozusagen, wenn du tot bist,

00:45:08.920 --> 00:45:10.520
eigentlich. Ein Lifehack, ja.

00:45:10.700 --> 00:45:11.520
Du musst irgendwie den,

00:45:11.780 --> 00:45:13.560
ja, irgendwas musst du diesen State verwalten.

00:45:13.680 --> 00:45:15.780
Irgendwas musst du halt sagen, okay, jetzt bist du aber tot.

00:45:16.380 --> 00:45:17.600
So, und dann darfst du nicht durch,

00:45:17.980 --> 00:45:19.720
darf nicht irgendein anderer Teil des Codes,

00:45:19.880 --> 00:45:21.040
der jetzt nicht weiß, ob du tot bist oder nicht,

00:45:21.620 --> 00:45:24.000
einfach deine Lebensenergie

00:45:24.000 --> 00:45:25.620
oder deine Lebenspunkte erhöhen, weil

00:45:25.620 --> 00:45:27.780
das macht dich ja eventuell wieder lebendig in einer Situation,

00:45:27.940 --> 00:45:28.600
wo das gar nicht gehen darf.

00:45:30.300 --> 00:45:31.780
Also, sozusagen, es ist...

00:45:32.380 --> 00:45:33.820
Also, das würde nicht so gut funktionieren.

00:45:33.900 --> 00:45:35.480
Das heißt, da würde man auch auch klassenbasiert

00:45:35.480 --> 00:45:37.780
einen Ansatz nehmen, wo man irgendwie sowas machen

00:45:37.780 --> 00:45:39.720
wie erhöhe Lebenspunkte und reduziere Lebenspunkte

00:45:39.720 --> 00:45:41.660
und der macht das halt dann nur dann, wenn man nicht tot ist.

00:45:41.780 --> 00:45:44.060
Oder so. Genau, und das erhöhe Lebenspunkte

00:45:44.060 --> 00:45:45.400
geht halt nur, solange man nicht tot ist, zum Beispiel.

00:45:45.600 --> 00:45:48.060
Aber diese Logik, wie das funktioniert,

00:45:48.160 --> 00:45:49.700
wäre dann halt an einem Ort

00:45:49.700 --> 00:45:51.640
gebündelt. Das wäre so ein bisschen die Idee auch hinter Klassen.

00:45:53.300 --> 00:45:53.780
Haupt hinter

00:45:53.780 --> 00:45:55.620
Objekt oder Theaterprogrammierung, dass du halt

00:45:55.620 --> 00:45:57.660
die ganze Komplexität irgendwie

00:45:57.660 --> 00:45:59.180
verbirgst.

00:45:59.980 --> 00:46:01.880
Hinter, ja,

00:46:02.060 --> 00:46:03.780
hinter dieser...

00:46:03.780 --> 00:46:05.140
In diesem Objekt, hinter einer API.

00:46:05.660 --> 00:46:07.340
Genau, und dann das halt alles nicht mehr wissen musst.

00:46:07.420 --> 00:46:09.540
Während, wenn du jetzt einfach nur eine Variable hast, die da irgendwie

00:46:09.540 --> 00:46:11.280
verändern kann, dann

00:46:11.280 --> 00:46:13.180
ist die Komplexität verteilt

00:46:13.180 --> 00:46:15.260
über den gesamten Code irgendwie,

00:46:15.460 --> 00:46:16.940
der mit dieser Variable interagiert.

00:46:17.120 --> 00:46:19.560
Was wäre denn jetzt aber ein cleveres Beispiel für eine globale Variable,

00:46:19.720 --> 00:46:21.660
wo man sagen würde, hey, da macht das um jetzt dann doch Sinn?

00:46:22.260 --> 00:46:23.280
Ich würde ich...

00:46:23.280 --> 00:46:25.940
Mir fällt da fast keins ein, wo das irgendwie sinnvoll ist.

00:46:26.140 --> 00:46:27.620
Also, was man manchmal hat,

00:46:27.700 --> 00:46:29.760
ist, dass man sicher sein möchte,

00:46:29.920 --> 00:46:31.420
dass man etwas

00:46:31.420 --> 00:46:33.840
nur einmal hat oder so.

00:46:34.000 --> 00:46:35.620
Aber da würde man auch

00:46:35.620 --> 00:46:36.980
eher einen Singleton nehmen, beziehungsweise

00:46:36.980 --> 00:46:38.080
in Python eher Borg-Personen.

00:46:38.080 --> 00:46:39.500
Oh, Singleton, das steht hier ein bisschen weiter unten.

00:46:39.600 --> 00:46:40.140
Nein, Singleton.

00:46:41.280 --> 00:46:43.440
Ja, okay.

00:46:44.240 --> 00:46:44.840
Was ist ein Singleton?

00:46:44.840 --> 00:46:45.780
Was ist ein Borg-Personen?

00:46:45.880 --> 00:46:48.940
Also, sozusagen,

00:46:50.960 --> 00:46:52.460
Singleton ist,

00:46:53.340 --> 00:46:54.920
wenn garantiert sein soll,

00:46:55.040 --> 00:46:57.020
dass es von einer bestimmten Geschichte nur eine Instanz gibt.

00:46:57.240 --> 00:46:58.720
Also, wenn ich zum Beispiel

00:46:58.720 --> 00:47:01.140
eben in einem Spiel

00:47:01.140 --> 00:47:02.840
die Spielfigur

00:47:04.020 --> 00:47:05.320
oder so, die dann bestimmte Eigenschaften hat,

00:47:05.700 --> 00:47:07.020
wie eben sowas wie Lebensenergie oder so,

00:47:07.860 --> 00:47:08.960
wenn ich garantieren möchte,

00:47:09.100 --> 00:47:10.560
dass alle, die damit interagieren,

00:47:10.660 --> 00:47:11.260
immer die gleiche Instanz haben,

00:47:11.260 --> 00:47:13.580
dass ich halt den nicht, weil es gibt nur einen,

00:47:13.700 --> 00:47:15.060
es ist ja jetzt blöd, wenn ich zwei davon erzeuge

00:47:15.060 --> 00:47:16.840
und dann in dem einen Objekt

00:47:16.840 --> 00:47:19.620
verjähre ich die Lebensenergie und beim anderen nicht oder so.

00:47:19.700 --> 00:47:21.460
Wie macht man das denn? Überschreibt man dann die New-Methode

00:47:21.460 --> 00:47:23.460
und sagt dann so, nee, wenn es schon eins gibt, dann mach keinen neuen?

00:47:24.340 --> 00:47:25.560
Ja, das ist, nee,

00:47:25.700 --> 00:47:26.620
eigentlich, also,

00:47:26.800 --> 00:47:29.120
dann kommt es in Borg-Python, so wird das üblicherweise

00:47:29.120 --> 00:47:30.180
dann in Python implementiert,

00:47:30.820 --> 00:47:32.560
man macht es einfach so, dass

00:47:32.560 --> 00:47:35.700
wie ging das?

00:47:36.260 --> 00:47:37.300
Also, ich glaube, der Trick ist,

00:47:38.200 --> 00:47:39.320
aber das muss man mal nachgucken,

00:47:39.320 --> 00:47:40.460
also mit Vorsicht genießen,

00:47:41.260 --> 00:47:43.460
ist das sozusagen

00:47:43.460 --> 00:47:45.720
den State innerhalb

00:47:45.720 --> 00:47:47.040
von der,

00:47:47.820 --> 00:47:49.180
eines Objekts sozusagen

00:47:49.180 --> 00:47:51.740
in der Klassenvariable zu halten, die halt

00:47:51.740 --> 00:47:53.740
bei allen Instanzen gleich ist. Und das, dann können

00:47:53.740 --> 00:47:55.960
die Instanzen zwar unterschiedlich sein, aber der State ist immer gleich.

00:47:57.180 --> 00:47:57.520
Und

00:47:57.520 --> 00:47:59.800
dann ist es zwar kein Singleton in dem

00:47:59.800 --> 00:48:02.040
Sinne, wie man das vielleicht ursprünglich

00:48:02.040 --> 00:48:03.860
mal so definiert hat, in Gänger-Vorbuch

00:48:03.860 --> 00:48:05.760
gibt es halt das Pattern Singleton,

00:48:06.760 --> 00:48:07.980
weil man eben nicht

00:48:07.980 --> 00:48:09.360
immer tatsächlich, also ich glaube,

00:48:09.460 --> 00:48:11.160
bei der ursprünglichen Singleton-Beschreibung,

00:48:11.260 --> 00:48:12.420
das wird einfach immer die

00:48:12.420 --> 00:48:16.000
gleiche Instanz returnt, wenn man halt die...

00:48:16.000 --> 00:48:17.760
Also, das heißt, wenn du überschreiben, das würde halt bedeuten,

00:48:17.840 --> 00:48:19.540
wenn es dann ein anderes gibt, returnt es halt das.

00:48:20.980 --> 00:48:21.860
Returnt es das alte halt.

00:48:22.200 --> 00:48:23.800
Sowas kann man auch in Python machen, das wäre kein Problem,

00:48:23.940 --> 00:48:25.720
aber praktischer ist es halt, weil es einfach weniger Code

00:48:25.720 --> 00:48:27.600
und macht sozusagen,

00:48:27.700 --> 00:48:30.020
verhält sich ähnlich und hat noch ein paar andere nette Vorteile,

00:48:30.780 --> 00:48:32.280
dass du halt sozusagen

00:48:32.280 --> 00:48:33.380
sagst, der State ist

00:48:33.380 --> 00:48:34.900
über alle Instanzen verteilt,

00:48:35.180 --> 00:48:37.820
bleibt über alle Instanzen von diesem Objekt gleich

00:48:37.820 --> 00:48:39.820
und ich muss da nicht kompliziert irgendwie

00:48:39.820 --> 00:48:41.140
dafür sorgen, dass ich immer die gleiche Instanz

00:48:41.140 --> 00:48:41.240
zurückgebe.

00:48:41.260 --> 00:48:42.720
Weil, wen interessiert es?

00:48:44.620 --> 00:48:47.260
Ja, aber genau,

00:48:47.360 --> 00:48:49.580
das sind alles, es geht immer so um State Handling

00:48:49.580 --> 00:48:50.360
im Grunde, das ist immer so,

00:48:50.700 --> 00:48:53.380
und wer manipuliert den und wie kann man

00:48:53.380 --> 00:48:55.260
dafür sorgen, dass man

00:48:55.260 --> 00:48:57.760
den Code,

00:48:57.800 --> 00:48:59.320
der den State manipuliert, an einer Stelle

00:48:59.320 --> 00:49:00.020
behält und so.

00:49:01.020 --> 00:49:03.260
Weil das ist immer so, das ist was, was man am Anfang

00:49:03.260 --> 00:49:04.900
das ist ein bisschen unintuitiv,

00:49:05.280 --> 00:49:07.160
das denkt man sich so, naja,

00:49:07.220 --> 00:49:09.240
das ist ja kein Problem, State kann irgendwo sein,

00:49:09.240 --> 00:49:10.960
egal, ist in einer Variable,

00:49:10.960 --> 00:49:12.160
in einer globalen Variable oder so,

00:49:12.320 --> 00:49:14.800
oder halt auch oft verteilt,

00:49:15.340 --> 00:49:16.260
oder man hat die Klassen,

00:49:16.540 --> 00:49:18.560
sich mal irgendwie überlegt, wie so eine

00:49:18.560 --> 00:49:20.080
Klassenhierarchie aussehen soll oder so,

00:49:20.260 --> 00:49:23.000
und zieht das dann durch, unabhängig

00:49:23.000 --> 00:49:24.380
davon, wie das Problem eigentlich ist.

00:49:24.880 --> 00:49:26.860
Und das fiese, was

00:49:26.860 --> 00:49:28.540
manchmal dann, oder fast immer passiert,

00:49:28.860 --> 00:49:31.180
ist, dass man dann halt den State verteilt

00:49:31.180 --> 00:49:32.740
über viel Code und

00:49:32.740 --> 00:49:33.420
das ist dann halt

00:49:33.420 --> 00:49:37.100
das, was du

00:49:37.100 --> 00:49:38.140
speichern musst,

00:49:38.400 --> 00:49:39.540
was sich irgendwie ändert.

00:49:40.360 --> 00:49:40.480
Also,

00:49:40.960 --> 00:49:42.280
der Status.

00:49:42.280 --> 00:49:42.560
Ja,

00:49:42.980 --> 00:49:46.380
also, sagen wir mal so, bei einer Web-Applikation

00:49:46.380 --> 00:49:47.960
würde man sagen, dass der State

00:49:47.960 --> 00:49:50.160
einer Web-Applikation liegt üblicherweise dann eben

00:49:50.160 --> 00:49:50.840
in einer Datenbank.

00:49:52.180 --> 00:49:53.280
Also, das ist in der klassischen...

00:49:53.280 --> 00:49:56.320
Was bedeutet das? Also, was ist denn

00:49:56.320 --> 00:49:58.220
überhaupt dann der State? Sagt der,

00:49:58.780 --> 00:50:00.220
wie der Nutzer

00:50:00.220 --> 00:50:02.080
gerade aussehen soll, wie der heißt und

00:50:02.080 --> 00:50:04.080
was er für Daten gespeichert hat

00:50:04.080 --> 00:50:06.160
für sein Profil, was er sehen soll

00:50:06.160 --> 00:50:08.060
und dass das halt nicht dynamisch generiert,

00:50:08.160 --> 00:50:09.360
sondern es liegt dann irgendwo rum.

00:50:10.480 --> 00:50:10.920
Ja.

00:50:10.920 --> 00:50:12.100
Das heißt, wenn man das ändern möchte,

00:50:12.200 --> 00:50:13.700
dann muss man erst die Datenbank fragen oder sowas.

00:50:13.740 --> 00:50:15.060
Das macht man dann gar nicht woanders.

00:50:16.960 --> 00:50:17.520
Ja, genau.

00:50:17.520 --> 00:50:17.920
Also,

00:50:18.060 --> 00:50:23.820
das, was halt sozusagen

00:50:23.820 --> 00:50:25.920
beschreibt, in welchem Zustand

00:50:25.920 --> 00:50:26.840
deine Applikation ist.

00:50:27.160 --> 00:50:28.400
Gehen wir jetzt nochmal aufs Spiel kurz.

00:50:28.660 --> 00:50:31.700
Was mit der Figur ist. Was hat die gerade für eine Waffe in der Hand?

00:50:32.300 --> 00:50:34.020
Was für eine Energie hat die? Wie viel Rüstung hat die noch an?

00:50:34.120 --> 00:50:34.760
Das wäre der State.

00:50:35.120 --> 00:50:37.780
Es geht so irgendwo in einen virtuellen Laden

00:50:37.780 --> 00:50:39.480
und kaufst dir irgendwie das magische

00:50:39.480 --> 00:50:40.800
sonst was Schwert, Feuerschwert.

00:50:40.920 --> 00:50:42.220
Mit dem du irgendwie alle platt machen kannst.

00:50:42.820 --> 00:50:44.560
Dann muss ja irgendwo gespeichert werden,

00:50:44.700 --> 00:50:45.460
dass du das jetzt hast.

00:50:45.580 --> 00:50:46.600
Dass das eine Adventure ist.

00:50:46.600 --> 00:50:48.800
Und ich darf aber auch keine zwei gleichzeitigen Sachen

00:50:48.800 --> 00:50:49.380
dann irgendwie haben.

00:50:49.500 --> 00:50:50.620
Damit das sich jetzt nicht widerspricht,

00:50:50.740 --> 00:50:51.720
darf es immer nur ein State geben.

00:50:52.680 --> 00:50:54.840
Die interessante Frage ist,

00:50:54.920 --> 00:50:57.020
wie verwaltet man diesen State?

00:50:58.840 --> 00:51:02.260
Und naiv wäre halt,

00:51:02.720 --> 00:51:04.040
man hat halt zum Beispiel

00:51:04.040 --> 00:51:06.260
Held heißt halt in irgendwelchen globalen Variablen.

00:51:06.460 --> 00:51:07.220
Man hat halt eine Liste.

00:51:07.400 --> 00:51:08.160
Linke Hand, rechte Hand.

00:51:08.200 --> 00:51:08.840
Die ist halt global.

00:51:09.500 --> 00:51:10.720
Genau, da steht halt drin,

00:51:10.920 --> 00:51:13.280
hier ist halt das Flammenschwert

00:51:13.280 --> 00:51:15.680
und das ist da jetzt in dieser Liste der Items drin.

00:51:16.220 --> 00:51:19.460
Und alle manipulieren diese Liste von Items irgendwie.

00:51:19.660 --> 00:51:21.320
Aber das macht dann halt Probleme,

00:51:21.460 --> 00:51:23.720
weil dann ist Logik jetzt irgendwie

00:51:23.720 --> 00:51:25.860
solche Sachen abbildet,

00:51:25.960 --> 00:51:28.740
wie das Flammenschwert macht jetzt plus 10 Angriff,

00:51:28.960 --> 00:51:30.980
aber auf der anderen Seite wird dir heiß.

00:51:31.060 --> 00:51:33.100
Das heißt, wird dir die Hand heiß

00:51:33.100 --> 00:51:34.880
und du verlierst irgendwie alle halbe Stunde

00:51:34.880 --> 00:51:35.880
ein paar Lebenspunkte oder sowas.

00:51:35.960 --> 00:51:36.300
Keine Ahnung.

00:51:38.260 --> 00:51:39.100
Das ist ja Code,

00:51:39.100 --> 00:51:40.720
der irgendwie diese,

00:51:40.720 --> 00:51:41.740
Business-Logik,

00:51:41.820 --> 00:51:42.540
wenn man das so sagen kann,

00:51:42.540 --> 00:51:44.400
in dem Spiel halt implementiert.

00:51:44.520 --> 00:51:45.180
Und das kann ja sein,

00:51:45.260 --> 00:51:46.280
dass da unterschiedlicher Code

00:51:46.280 --> 00:51:47.320
an unterschiedlichen Stellen steht.

00:51:47.800 --> 00:51:50.140
Und wenn du jetzt überall das gleiche globale,

00:51:50.340 --> 00:51:53.840
die gleiche globale Variable hast,

00:51:53.980 --> 00:51:54.860
auf die du zugreifst,

00:51:55.200 --> 00:51:55.940
dann musst du dafür sorgen,

00:51:56.040 --> 00:51:56.820
dass dieser gesamte Code,

00:51:56.940 --> 00:51:59.520
der halt über dein Projekt verteilt sein kann,

00:51:59.960 --> 00:52:01.260
dass der immer weiß,

00:52:01.320 --> 00:52:02.180
was alle anderen Sachen machen.

00:52:02.260 --> 00:52:04.080
Und das geht ab einer gewissen Größe nicht mehr.

00:52:04.180 --> 00:52:04.640
Das geht am Anfang,

00:52:04.780 --> 00:52:04.960
geht das,

00:52:05.160 --> 00:52:06.200
solange es alles sehr klein ist,

00:52:06.960 --> 00:52:07.700
kriegt man das auch noch hin,

00:52:07.740 --> 00:52:08.700
dass man das alles im Kopf behält.

00:52:08.700 --> 00:52:10.060
Ja, du musst halt jedes Mal zumindest

00:52:10.060 --> 00:52:11.100
diese Überprüfung machen.

00:52:11.180 --> 00:52:11.820
Du musst halt jedes Mal gucken,

00:52:11.900 --> 00:52:13.400
hat denn jemand irgendwas geändert an der Stelle,

00:52:13.520 --> 00:52:14.060
das nicht sein darf.

00:52:14.140 --> 00:52:14.380
Das heißt,

00:52:14.460 --> 00:52:15.620
jede dieser Logiken müsstest du

00:52:15.620 --> 00:52:17.740
bei jeder Stelle,

00:52:17.880 --> 00:52:19.740
wo diese globale Variable geändert wird,

00:52:20.020 --> 00:52:20.520
erneut machen,

00:52:20.660 --> 00:52:22.200
was halt dem Don't Repeat Yourself

00:52:22.200 --> 00:52:23.260
widerspricht und so.

00:52:24.940 --> 00:52:26.480
Das kann schon durchaus so sein,

00:52:26.600 --> 00:52:27.740
dass man sich da nicht wiederholt,

00:52:27.860 --> 00:52:30.360
aber du kannst halt Änderungen machen,

00:52:30.420 --> 00:52:31.980
die dann nicht lokale Auswirkungen haben.

00:52:33.020 --> 00:52:33.500
Also nehmen wir an,

00:52:33.520 --> 00:52:34.500
du weißt das halt alles nicht.

00:52:34.640 --> 00:52:35.000
Du weißt halt,

00:52:35.060 --> 00:52:36.820
du machst jetzt halt ein neues Item,

00:52:37.400 --> 00:52:37.840
sozusagen,

00:52:37.940 --> 00:52:39.200
das irgendwelche Spezialgeschichten hat,

00:52:39.540 --> 00:52:40.040
schreibst da Code,

00:52:40.060 --> 00:52:41.300
dass das halt irgendwie tut.

00:52:42.660 --> 00:52:44.100
Und dabei bedenkst du aber nicht,

00:52:44.280 --> 00:52:46.260
dass unter bestimmten Umständen

00:52:46.260 --> 00:52:47.020
irgendwelcher anderer Code

00:52:47.020 --> 00:52:47.780
irgendwas anderes tut.

00:52:48.020 --> 00:52:49.520
Und dann passieren halt Fehler

00:52:49.520 --> 00:52:50.560
und seltsame Effekte.

00:52:51.520 --> 00:52:52.640
Und solange man halt

00:52:52.640 --> 00:52:54.360
von dem ganzen anderen Code,

00:52:54.400 --> 00:52:55.060
der irgendwie daran rummanipuliert,

00:52:55.900 --> 00:52:56.480
irgendwie weiß,

00:52:56.640 --> 00:52:57.200
ist das ja okay.

00:52:57.360 --> 00:52:59.180
Aber sobald das Projekt irgendwie größer wird,

00:52:59.560 --> 00:53:00.380
geht das irgendwann nicht mehr.

00:53:00.540 --> 00:53:03.220
Und dann kann man überhaupt nicht vorhersagen,

00:53:03.320 --> 00:53:04.020
was passieren wird,

00:53:04.080 --> 00:53:06.800
wenn man jetzt irgendwie Dinge ändert.

00:53:06.960 --> 00:53:08.240
Wie man manipuliert irgendwas

00:53:08.240 --> 00:53:09.300
an den Lebenspunkten oder so.

00:53:09.300 --> 00:53:10.040
Und dann gibt es irgendwann

00:53:10.040 --> 00:53:10.380
was anderes,

00:53:10.500 --> 00:53:12.120
was wiederum nochmal was anderes macht.

00:53:12.120 --> 00:53:14.260
Ich bin der Invincible Geist.

00:53:14.760 --> 00:53:14.780
Ja.

00:53:15.240 --> 00:53:15.380
Ja.

00:53:15.620 --> 00:53:17.640
Und das Mittel dagegen ist halt,

00:53:17.720 --> 00:53:20.400
dass du eben nicht direkt die Daten

00:53:20.400 --> 00:53:21.920
pro anfasst,

00:53:22.040 --> 00:53:23.680
sondern dass du sagst,

00:53:23.780 --> 00:53:24.000
okay,

00:53:25.780 --> 00:53:27.260
wir haben hier eine Klasse oder so

00:53:27.260 --> 00:53:27.880
und der ist,

00:53:28.120 --> 00:53:30.180
bündeln wir den State,

00:53:30.260 --> 00:53:30.880
also die Daten,

00:53:31.780 --> 00:53:33.260
und die Logik,

00:53:33.880 --> 00:53:34.900
die jetzt irgendwas damit macht.

00:53:35.260 --> 00:53:38.360
Und haben dann eine API nach außen,

00:53:38.500 --> 00:53:39.160
die öffentlich ist.

00:53:39.160 --> 00:53:39.520
Und,

00:53:39.520 --> 00:53:39.940
äh,

00:53:41.480 --> 00:53:43.020
können sozusagen immer überprüfen,

00:53:43.100 --> 00:53:44.480
dass alles ordentlich ist an einer Stelle.

00:53:44.680 --> 00:53:44.860
Und dann,

00:53:45.420 --> 00:53:45.600
ja.

00:53:46.600 --> 00:53:47.260
Ja, die Frage war,

00:53:47.480 --> 00:53:48.460
was ist ein Objekt in Python?

00:53:49.000 --> 00:53:50.200
Was ist ein Objekt in Python?

00:53:50.360 --> 00:53:50.480
Ja.

00:53:51.140 --> 00:53:51.580
Ähm,

00:53:53.920 --> 00:53:54.620
äh,

00:53:54.900 --> 00:53:57.060
ich würde es jetzt mal sagen,

00:53:57.300 --> 00:53:58.520
das erklärt aber nicht viel,

00:53:58.920 --> 00:53:59.380
äh,

00:53:59.700 --> 00:54:00.900
ist halt die Instanz,

00:54:01.540 --> 00:54:01.880
äh,

00:54:02.060 --> 00:54:03.880
konkretisierte Instanz von irgendwie

00:54:03.880 --> 00:54:05.060
einer Klasse.

00:54:06.760 --> 00:54:07.080
Also,

00:54:07.220 --> 00:54:09.500
in einer Klasse definiert man sozusagen,

00:54:09.520 --> 00:54:09.880
irgendwie,

00:54:10.160 --> 00:54:10.320
äh,

00:54:10.320 --> 00:54:10.500
ja,

00:54:10.780 --> 00:54:12.320
äh,

00:54:12.760 --> 00:54:12.900
äh,

00:54:13.260 --> 00:54:14.460
eben eine Zusammenfassung von,

00:54:14.520 --> 00:54:14.660
von,

00:54:14.780 --> 00:54:15.460
von irgendwie Code,

00:54:15.560 --> 00:54:16.000
der was tut.

00:54:16.200 --> 00:54:16.400
Und,

00:54:16.480 --> 00:54:16.800
äh,

00:54:16.860 --> 00:54:17.520
irgendwie Daten,

00:54:17.780 --> 00:54:17.940
äh,

00:54:17.940 --> 00:54:18.920
die man irgendwie halten will.

00:54:19.120 --> 00:54:19.440
Und,

00:54:19.540 --> 00:54:19.880
ähm,

00:54:20.400 --> 00:54:21.080
wenn man das jetzt,

00:54:21.180 --> 00:54:21.940
das ist halt sozusagen die,

00:54:22.060 --> 00:54:22.200
die,

00:54:22.380 --> 00:54:22.660
äh,

00:54:22.900 --> 00:54:23.800
Beschreibung.

00:54:24.000 --> 00:54:24.640
Und wenn man da jetzt rauskommt.

00:54:24.640 --> 00:54:26.320
Ich sag nicht so besonders an von dem Code,

00:54:26.420 --> 00:54:26.680
der irgendwie,

00:54:26.900 --> 00:54:28.940
irgendwie Beschreibung von irgendwelchen Sachen.

00:54:29.660 --> 00:54:30.020
Ja,

00:54:30.160 --> 00:54:30.360
also,

00:54:30.480 --> 00:54:30.820
äh,

00:54:30.900 --> 00:54:31.680
man könnte das vielleicht,

00:54:31.800 --> 00:54:31.940
also,

00:54:32.160 --> 00:54:32.560
äh.

00:54:33.220 --> 00:54:34.120
Also ein Objekt ist ein Ding.

00:54:34.440 --> 00:54:35.580
Also ich glaube in Python ist alles ein Ding.

00:54:35.580 --> 00:54:36.260
Oder ein Objekt,

00:54:36.360 --> 00:54:36.420
oder?

00:54:36.420 --> 00:54:37.020
Alles ein Objekt,

00:54:37.100 --> 00:54:37.240
ja.

00:54:37.800 --> 00:54:37.940
Also,

00:54:38.040 --> 00:54:39.260
also alles was es in Python gibt,

00:54:39.320 --> 00:54:40.320
kann sich als Objekt darstellen.

00:54:40.420 --> 00:54:41.240
Also ein Objekt ist immer,

00:54:41.240 --> 00:54:42.880
ein Instanz einer Klasse,

00:54:43.420 --> 00:54:44.020
wenn man das so sagt.

00:54:44.040 --> 00:54:44.180
Ja.

00:54:44.940 --> 00:54:45.300
Das heißt,

00:54:45.460 --> 00:54:45.740
ähm,

00:54:46.040 --> 00:54:48.820
alles was ihr habt in Python sind tatsächlich Instanzen von irgendwelchen Klassen,

00:54:48.900 --> 00:54:49.540
von irgendwelchen Dingen.

00:54:49.780 --> 00:54:49.920
Ja.

00:54:50.660 --> 00:54:50.880
Ähm,

00:54:51.000 --> 00:54:51.120
da,

00:54:51.200 --> 00:54:51.800
die nächste Frage war,

00:54:51.840 --> 00:54:52.420
was ist Self?

00:54:52.720 --> 00:54:53.180
Self ist,

00:54:53.260 --> 00:54:53.380
äh,

00:54:53.380 --> 00:54:54.260
immer das Objekt selbst.

00:54:54.440 --> 00:54:54.800
Also wenn man,

00:54:54.980 --> 00:54:55.580
wenn das Objekt,

00:54:55.580 --> 00:54:55.940
auch eine,

00:54:56.180 --> 00:54:57.380
ist eine Konvention sozusagen,

00:54:57.440 --> 00:54:58.060
dass man das so nennt.

00:54:58.180 --> 00:54:58.380
Aber,

00:54:58.600 --> 00:54:59.680
äh,

00:54:59.980 --> 00:55:01.160
sehr sinnvoll das so zu machen.

00:55:01.820 --> 00:55:02.140
Außer,

00:55:02.260 --> 00:55:03.260
es gibt wiederum Spezialfälle,

00:55:03.260 --> 00:55:04.400
bei denen man das ein bisschen anders macht.

00:55:04.600 --> 00:55:04.620
Also,

00:55:04.680 --> 00:55:05.260
wenn man,

00:55:05.340 --> 00:55:06.660
ähm,

00:55:06.720 --> 00:55:07.160
äh,

00:55:07.820 --> 00:55:08.060
äh,

00:55:08.100 --> 00:55:08.740
eine Methode hat,

00:55:08.800 --> 00:55:10.880
also Methode ist nichts weiter als eine Funktion,

00:55:11.500 --> 00:55:13.040
die sozusagen an so ein,

00:55:13.860 --> 00:55:14.360
so eine,

00:55:14.500 --> 00:55:17.100
Instanz an so ein Objekt gebunden ist.

00:55:18.240 --> 00:55:18.640
Und,

00:55:18.760 --> 00:55:19.140
ähm,

00:55:19.340 --> 00:55:20.100
jetzt möchte man halt,

00:55:20.240 --> 00:55:20.400
äh,

00:55:20.420 --> 00:55:21.520
um zum Beispiel auf die Daten,

00:55:21.600 --> 00:55:22.260
die man halten möchte,

00:55:22.340 --> 00:55:23.220
in so einem Objekt,

00:55:23.420 --> 00:55:23.740
äh,

00:55:23.940 --> 00:55:24.100
äh,

00:55:24.100 --> 00:55:25.200
um da drauf zuzugreifen,

00:55:25.260 --> 00:55:26.980
muss man ja irgendwie sich selbst referenzieren können.

00:55:27.460 --> 00:55:29.680
Deswegen wird immer als erstes Argument in Methoden,

00:55:30.480 --> 00:55:30.640
äh,

00:55:30.700 --> 00:55:31.520
das ist halt auch das,

00:55:31.520 --> 00:55:33.240
was dann Methoden von Funktionen unterscheidet,

00:55:33.260 --> 00:55:33.580
äh,

00:55:33.780 --> 00:55:34.200
immer,

00:55:34.440 --> 00:55:34.580
äh,

00:55:34.580 --> 00:55:35.640
eine Referenz auf,

00:55:36.500 --> 00:55:36.740
das,

00:55:36.940 --> 00:55:37.120
äh,

00:55:37.160 --> 00:55:37.320
auf,

00:55:37.380 --> 00:55:38.140
auf sich selbst,

00:55:38.260 --> 00:55:38.500
äh,

00:55:38.540 --> 00:55:39.400
sozusagen mit übergeben.

00:55:39.880 --> 00:55:40.080
Ja.

00:55:40.080 --> 00:55:41.020
Man könnte das auch anders nennen.

00:55:41.480 --> 00:55:41.580
Ja,

00:55:41.600 --> 00:55:42.220
man kann auch sagen,

00:55:42.520 --> 00:55:43.020
äh,

00:55:43.540 --> 00:55:44.300
A statt Self,

00:55:44.400 --> 00:55:45.080
dann ist es A,

00:55:45.220 --> 00:55:45.460
aber,

00:55:45.640 --> 00:55:45.860
ähm,

00:55:45.860 --> 00:55:46.480
es ist schon sinnvoll,

00:55:46.520 --> 00:55:47.020
das Self zu nennen,

00:55:47.100 --> 00:55:47.440
damit man weiß,

00:55:47.480 --> 00:55:49.940
dass es halt eine Referenz auf sich selbst ist,

00:55:50.140 --> 00:55:50.420
sozusagen,

00:55:50.560 --> 00:55:51.060
auf das Objekt,

00:55:51.140 --> 00:55:51.600
was gerade,

00:55:52.220 --> 00:55:52.920
was man gerade ist.

00:55:53.180 --> 00:55:56.060
Und dann kann man halt auf Self-Punkt irgendwelche Daten zugreifen.

00:55:56.320 --> 00:55:56.520
Okay.

00:55:56.940 --> 00:55:57.260
Ähm,

00:55:57.260 --> 00:55:58.840
da fangen wir jetzt direkt ein paar andere Sachen ein,

00:55:58.900 --> 00:56:00.400
weil wir jetzt das gerade jetzt so hatten mit Objekt,

00:56:00.400 --> 00:56:00.600
ne,

00:56:00.680 --> 00:56:01.220
was ist denn ein Objekt?

00:56:01.340 --> 00:56:02.060
Dann ist das eine Klasse.

00:56:02.240 --> 00:56:04.020
Und jetzt gibt es irgendwie drei Dekoratoren,

00:56:04.160 --> 00:56:05.640
also wir müssen noch gleich darüber sprechen,

00:56:05.700 --> 00:56:06.400
was ein Dekorator ist,

00:56:06.740 --> 00:56:08.080
aber es gibt drei Dekoratoren,

00:56:08.200 --> 00:56:08.300
die,

00:56:08.340 --> 00:56:08.600
ähm,

00:56:08.600 --> 00:56:09.380
Python verwendet,

00:56:09.500 --> 00:56:11.240
die da immer so drüber stehen.

00:56:11.680 --> 00:56:12.440
Das ist Dessig-Method,

00:56:12.560 --> 00:56:13.800
Class-Method und,

00:56:13.920 --> 00:56:14.640
ähm,

00:56:14.840 --> 00:56:15.180
Property.

00:56:15.640 --> 00:56:16.860
Über Property hattest du eben auch schon.

00:56:17.040 --> 00:56:17.200
Ähm,

00:56:17.600 --> 00:56:20.400
was ist denn jetzt da irgendwie so der kleine Haken?

00:56:21.240 --> 00:56:22.280
Also wann sagt man jetzt zum Beispiel,

00:56:22.380 --> 00:56:23.820
das ist eine statische Methode?

00:56:24.020 --> 00:56:24.480
Und wann sagt man,

00:56:24.480 --> 00:56:25.320
das ist eine Klassenmethode?

00:56:25.380 --> 00:56:25.500
Was,

00:56:25.540 --> 00:56:25.700
was,

00:56:25.700 --> 00:56:26.860
was heißt das denn in dem Kontext?

00:56:26.920 --> 00:56:28.340
To Self und Objekt und,

00:56:28.340 --> 00:56:29.100
äh,

00:56:29.660 --> 00:56:29.880
Ja,

00:56:30.060 --> 00:56:30.520
also ich würde,

00:56:30.580 --> 00:56:31.060
ich würde eigentlich,

00:56:31.160 --> 00:56:31.860
ähm,

00:56:31.940 --> 00:56:32.560
am liebsten mit,

00:56:32.620 --> 00:56:32.780
äh,

00:56:32.780 --> 00:56:34.340
der Klassenmethode anfangen.

00:56:34.680 --> 00:56:34.820
Also,

00:56:35.000 --> 00:56:35.440
äh,

00:56:35.440 --> 00:56:35.620
äh,

00:56:35.620 --> 00:56:35.860
Class-Method.

00:56:35.880 --> 00:56:37.760
Class-Method ist,

00:56:37.880 --> 00:56:38.260
äh,

00:56:38.400 --> 00:56:39.100
halt eine,

00:56:39.780 --> 00:56:40.620
ähm,

00:56:40.880 --> 00:56:41.380
äh,

00:56:41.380 --> 00:56:41.940
eine Methode,

00:56:42.060 --> 00:56:43.880
die eben nicht eine konkrete Instanz,

00:56:44.140 --> 00:56:44.540
äh,

00:56:44.660 --> 00:56:44.940
Das heißt,

00:56:44.980 --> 00:56:46.160
da fehlt auch Self bei der,

00:56:46.160 --> 00:56:46.320
Genau,

00:56:46.420 --> 00:56:46.540
da,

00:56:46.540 --> 00:56:48.360
da könnte man jetzt auch Self übergeben,

00:56:48.460 --> 00:56:49.420
also es wäre dann sehr verwirrend.

00:56:50.100 --> 00:56:51.240
Sondern was man da üblicherweise,

00:56:51.480 --> 00:56:51.680
äh,

00:56:51.720 --> 00:56:52.100
übergibt,

00:56:52.220 --> 00:56:52.440
äh,

00:56:52.480 --> 00:56:52.680
ist,

00:56:52.820 --> 00:56:53.000
äh,

00:56:53.020 --> 00:56:55.320
man CLS oder so und bekommt man die Klasse übergeben.

00:56:55.320 --> 00:56:55.680
Na,

00:56:55.680 --> 00:56:56.720
die Klasse ist auch wieder ein Objekt.

00:56:57.640 --> 00:56:58.540
Das ist auch irgendwie,

00:56:58.640 --> 00:56:59.880
man kann das auch noch ein Stückchen weiter treiben,

00:56:59.940 --> 00:57:00.280
auch dann mit,

00:57:00.280 --> 00:57:00.960
mit Metaklassen.

00:57:01.600 --> 00:57:01.960
Aber,

00:57:02.080 --> 00:57:02.640
Also die kleinste,

00:57:02.640 --> 00:57:03.220
das kleinste Objekt,

00:57:03.320 --> 00:57:05.380
also jede Klasse ist irgendwie ein Objekt und das Objekt,

00:57:05.460 --> 00:57:07.200
Objekt und Objekt selber ist ein Objekt vom Typ,

00:57:07.300 --> 00:57:07.480
Typ.

00:57:08.280 --> 00:57:08.540
Hm.

00:57:08.880 --> 00:57:09.120
Ja,

00:57:09.160 --> 00:57:09.400
okay.

00:57:10.420 --> 00:57:10.780
Ja,

00:57:10.880 --> 00:57:11.040
okay.

00:57:11.640 --> 00:57:11.840
Ähm,

00:57:11.840 --> 00:57:12.080
man,

00:57:12.220 --> 00:57:12.400
äh,

00:57:12.440 --> 00:57:12.580
ja,

00:57:12.740 --> 00:57:12.960
also,

00:57:14.260 --> 00:57:14.680
ähm,

00:57:15.400 --> 00:57:15.840
jedenfalls,

00:57:15.980 --> 00:57:16.140
wenn,

00:57:16.260 --> 00:57:16.480
in der,

00:57:16.480 --> 00:57:19.120
in der Klassenmethode übergibt man halt CLS und nicht,

00:57:19.140 --> 00:57:19.500
äh,

00:57:19.540 --> 00:57:19.840
Self.

00:57:20.220 --> 00:57:20.740
Weil man damit,

00:57:20.800 --> 00:57:21.320
man halt weiß,

00:57:21.420 --> 00:57:23.040
dass man jetzt gerade die Klasse in der Hand hat und nicht,

00:57:23.040 --> 00:57:23.420
äh,

00:57:24.080 --> 00:57:24.300
nicht,

00:57:24.480 --> 00:57:24.780
äh,

00:57:24.780 --> 00:57:26.040
eine Referenz auf,

00:57:26.180 --> 00:57:26.420
äh,

00:57:26.480 --> 00:57:27.040
die Instanz.

00:57:27.620 --> 00:57:28.000
Und,

00:57:28.120 --> 00:57:28.420
ähm,

00:57:28.920 --> 00:57:29.140
äh,

00:57:29.140 --> 00:57:29.620
es gibt halt,

00:57:29.680 --> 00:57:30.860
das verwendet man vor allen Dingen dafür,

00:57:31.060 --> 00:57:31.580
dass man,

00:57:32.160 --> 00:57:33.300
es gibt halt bestimmte Methoden,

00:57:33.340 --> 00:57:34.520
die brauchen eben nicht,

00:57:34.720 --> 00:57:35.900
die müssen nicht auf irgendwelche,

00:57:36.020 --> 00:57:36.240
äh,

00:57:36.300 --> 00:57:37.420
internen Daten oder so zugreifen,

00:57:37.480 --> 00:57:38.100
weil die hat man ja nicht.

00:57:39.260 --> 00:57:39.620
Sondern,

00:57:40.160 --> 00:57:41.100
die machen halt,

00:57:41.560 --> 00:57:41.700
die,

00:57:41.760 --> 00:57:43.780
die gehören zwar vielleicht irgendwie in die Klasse rein,

00:57:43.860 --> 00:57:45.380
weil die Funktionalität,

00:57:45.420 --> 00:57:45.940
die sie bieten,

00:57:46.080 --> 00:57:47.520
halt sehr viel zu tun hat mit der Klasse.

00:57:48.140 --> 00:57:49.080
Aber die verwalten,

00:57:49.220 --> 00:57:49.580
verhalten,

00:57:49.580 --> 00:57:51.280
verhalten sie in gewisser Weise natürlich dann so wie,

00:57:51.520 --> 00:57:52.820
eine normale Funktion.

00:57:53.040 --> 00:57:53.220
Ähm,

00:57:54.140 --> 00:57:55.820
und vielleicht können sie auch auf Daten,

00:57:56.020 --> 00:57:59.500
die halt für alle Instanzen dieser Klasse gleich sind,

00:57:59.660 --> 00:58:00.700
zugreifen eben über die Klasse.

00:58:00.860 --> 00:58:01.020
Aber,

00:58:01.860 --> 00:58:02.300
ähm,

00:58:02.480 --> 00:58:03.980
die brauchen jetzt nicht die,

00:58:04.180 --> 00:58:04.640
ähm,

00:58:05.980 --> 00:58:06.180
nicht,

00:58:06.260 --> 00:58:07.600
nicht irgendwie eine konkrete Instanz,

00:58:07.700 --> 00:58:08.520
auf der sie irgendwas machen.

00:58:08.640 --> 00:58:09.480
Also Beispiel für,

00:58:09.720 --> 00:58:10.880
äh,

00:58:11.020 --> 00:58:11.820
sowas sind,

00:58:12.180 --> 00:58:13.580
was ist denn ein gutes Beispiel für,

00:58:15.060 --> 00:58:15.620
äh,

00:58:19.620 --> 00:58:20.920
jetzt bin ich schon aus dem Spiel.

00:58:21.340 --> 00:58:21.380
Also,

00:58:21.500 --> 00:58:22.380
die können zwei Beispiele,

00:58:22.480 --> 00:58:22.740
ich kann es,

00:58:22.740 --> 00:58:22.900
äh,

00:58:23.040 --> 00:58:24.260
gut visualisieren finde.

00:58:24.340 --> 00:58:25.300
Entweder hat man so ein Spiel,

00:58:25.440 --> 00:58:26.440
mit so Charakteren und so,

00:58:26.780 --> 00:58:29.240
oder man hat so ein Universum mit Planeten und Dingen,

00:58:29.340 --> 00:58:30.640
die umeinander kreisen oder sowas.

00:58:31.200 --> 00:58:33.480
Zwei verschiedene Sonnensysteme als zwei Klasse.

00:58:33.480 --> 00:58:33.740
Oh je.

00:58:34.080 --> 00:58:34.460
Aber okay,

00:58:34.580 --> 00:58:34.940
lass mir das.

00:58:35.220 --> 00:58:35.540
Äh,

00:58:35.660 --> 00:58:36.300
ich weiß nicht genau,

00:58:36.380 --> 00:58:37.020
ob ich was da irgendwie,

00:58:37.360 --> 00:58:37.600
also,

00:58:37.880 --> 00:58:41.880
äh,

00:58:42.740 --> 00:58:44.520
mir fällt da jetzt gar nichts.

00:58:44.620 --> 00:58:44.940
Also ich,

00:58:45.080 --> 00:58:45.440
man hat,

00:58:45.700 --> 00:58:47.680
also es sind oft irgendwelche Hilfsfunktionen oder so,

00:58:48.180 --> 00:58:48.440
die,

00:58:48.560 --> 00:58:48.840
äh,

00:58:48.860 --> 00:58:49.220
was machen,

00:58:49.300 --> 00:58:50.980
was logisch dann in der Klasse gehört,

00:58:51.080 --> 00:58:52.940
aber wo man nicht mit einer konkreten Instanz irgendwas,

00:58:52.940 --> 00:58:53.020
äh,

00:58:53.040 --> 00:58:53.380
zu tun hat.

00:58:54.220 --> 00:58:56.440
Mir fällt jetzt tatsächlich kein super tolles Beispiel.

00:58:57.180 --> 00:58:59.040
Was ist denn der besten Static Method?

00:58:59.140 --> 00:59:00.360
Was wäre das denn jetzt so als?

00:59:01.240 --> 00:59:01.600
Ja,

00:59:01.840 --> 00:59:02.600
Static Method,

00:59:03.280 --> 00:59:04.140
ähm,

00:59:06.200 --> 00:59:06.440
ah,

00:59:06.520 --> 00:59:08.800
die bekommt halt einfach tatsächlich überhaupt nicht mal die Klasse,

00:59:08.920 --> 00:59:09.020
ja.

00:59:10.460 --> 00:59:11.540
Aber im Prinzip ist es nichts anderes,

00:59:11.700 --> 00:59:11.760
außer,

00:59:11.960 --> 00:59:12.320
ähm,

00:59:12.500 --> 00:59:13.540
sie nur nicht mal die Klasse bekommt.

00:59:13.640 --> 00:59:13.700
Ja.

00:59:14.760 --> 00:59:14.980
Das heißt,

00:59:15.020 --> 00:59:16.260
sie könnte man auch draußen hinschreiben.

00:59:16.960 --> 00:59:17.220
Genau.

00:59:17.560 --> 00:59:19.080
Das einzige Unterschied bei der Static Method ist halt,

00:59:19.120 --> 00:59:22.980
dass sie dann im Namespace der Klasse oder des Objekts aufrufbar ist,

00:59:23.040 --> 00:59:23.280
oder so.

00:59:23.440 --> 00:59:23.560
Ja.

00:59:29.260 --> 00:59:29.580
Ja,

00:59:29.640 --> 00:59:31.120
was ist jetzt in dem Vergleich eine Static Method?

00:59:31.800 --> 00:59:32.120
Okay.

00:59:33.720 --> 00:59:34.060
Ja,

00:59:34.160 --> 00:59:34.340
also,

00:59:34.500 --> 00:59:34.760
äh,

00:59:34.760 --> 00:59:35.380
Static Method,

00:59:35.600 --> 00:59:35.860
äh,

00:59:35.920 --> 00:59:36.580
bekommt gar keiner,

00:59:36.760 --> 00:59:37.160
äh,

00:59:37.220 --> 00:59:37.620
gar kein,

00:59:37.880 --> 00:59:38.880
auch ein automatisches,

00:59:38.980 --> 00:59:39.220
äh,

00:59:39.220 --> 00:59:39.880
Argument mit,

00:59:40.620 --> 00:59:40.940
äh,

00:59:41.020 --> 00:59:41.360
sozusagen,

00:59:41.480 --> 00:59:42.360
also das wäre dann die reine,

00:59:42.620 --> 00:59:42.960
äh,

00:59:43.420 --> 00:59:44.560
wäre quasi wie eine Funktion,

00:59:44.700 --> 00:59:44.820
ja,

00:59:44.920 --> 00:59:45.780
also es ist egal,

00:59:45.840 --> 00:59:46.620
ob man jetzt Static Method,

00:59:46.840 --> 00:59:47.460
äh,

00:59:47.520 --> 00:59:48.840
aufruft oder halt,

00:59:48.980 --> 00:59:50.460
ähm,

00:59:50.460 --> 00:59:51.020
äh,

00:59:51.020 --> 00:59:51.380
ähm,

00:59:51.500 --> 00:59:52.380
Funktion von draußen,

00:59:52.380 --> 00:59:52.960
Funktion von draußen,

00:59:53.040 --> 00:59:53.580
genau,

00:59:53.720 --> 00:59:53.880
genau.

00:59:54.340 --> 00:59:54.580
Ah,

00:59:54.700 --> 00:59:54.880
äh,

00:59:54.920 --> 00:59:55.120
äh,

00:59:55.120 --> 00:59:55.320
richtig,

00:59:55.400 --> 00:59:57.120
jetzt fällt mir doch wieder ein Beispiel ein zu Class Method,

00:59:57.220 --> 00:59:57.540
wo das,

00:59:57.540 --> 00:59:57.780
äh,

00:59:58.240 --> 00:59:58.540
äh,

00:59:58.540 --> 00:59:58.740
äh,

00:59:58.740 --> 00:59:59.340
wenn man jetzt,

00:59:59.440 --> 00:59:59.680
äh,

00:59:59.780 --> 00:59:59.900
in,

00:59:59.900 --> 01:00:01.260
in Django zum Beispiel Modelle hat,

01:00:01.840 --> 01:00:02.200
dann,

01:00:02.440 --> 01:00:02.820
äh,

01:00:02.860 --> 01:00:03.520
sind halt,

01:00:03.720 --> 01:00:04.540
ähm,

01:00:05.380 --> 01:00:05.720
äh,

01:00:06.000 --> 01:00:06.400
viele,

01:00:06.640 --> 01:00:06.900
äh,

01:00:06.900 --> 01:00:07.580
viele Geschichten,

01:00:07.840 --> 01:00:08.980
die jetzt ein Modell betreffen,

01:00:09.200 --> 01:00:10.260
die man von außen aufrufen kann,

01:00:10.340 --> 01:00:11.480
ruft man halt auf der Klasse auf,

01:00:11.580 --> 01:00:12.260
und nicht auf der,

01:00:12.400 --> 01:00:13.040
auf einer Instanz,

01:00:13.160 --> 01:00:14.700
weil eine konkrete Instanz ist ja zum Beispiel,

01:00:15.500 --> 01:00:16.980
man hat ja die Daten für,

01:00:17.260 --> 01:00:17.580
äh,

01:00:18.100 --> 01:00:20.720
die Geschichten stehen halt in der Datenbank,

01:00:21.460 --> 01:00:23.020
und jetzt eine konkrete,

01:00:23.040 --> 01:00:24.460
konkrete Instanz eines,

01:00:24.720 --> 01:00:26.380
also Django Modelle sind Klassen,

01:00:27.220 --> 01:00:27.480
äh,

01:00:27.680 --> 01:00:29.920
und sie modellieren sozusagen den Zustand,

01:00:30.040 --> 01:00:31.140
der irgendwie in der Datenbank steht,

01:00:31.460 --> 01:00:33.020
und eine Instanz,

01:00:34.080 --> 01:00:35.440
üblicherweise ist halt eine Zeile,

01:00:35.540 --> 01:00:36.280
also wenn ich jetzt zum Beispiel,

01:00:36.440 --> 01:00:36.680
äh,

01:00:36.920 --> 01:00:37.720
Beispiel User nehme,

01:00:37.840 --> 01:00:37.960
ja,

01:00:38.080 --> 01:00:39.120
also ein User Objekt,

01:00:39.300 --> 01:00:39.560
äh,

01:00:39.640 --> 01:00:43.900
in Django ist halt eine Zeile aus der Tabelle Users irgendwie,

01:00:44.460 --> 01:00:45.000
und,

01:00:45.060 --> 01:00:45.200
äh,

01:00:45.240 --> 01:00:46.880
hat halt all die Attribute,

01:00:47.020 --> 01:00:48.200
die jetzt irgendwie die Zeile hat,

01:00:48.520 --> 01:00:49.460
also als Spalten hat,

01:00:49.560 --> 01:00:50.360
sozusagen in dieser Tabelle,

01:00:50.500 --> 01:00:50.620
ja.

01:00:51.000 --> 01:00:51.160
Ja,

01:00:51.160 --> 01:00:51.520
ähm,

01:00:51.700 --> 01:00:52.720
aber jetzt,

01:00:52.720 --> 01:00:53.120
äh,

01:00:53.180 --> 01:00:54.700
aber ich möchte jetzt möglicherweise Dinge machen,

01:00:54.740 --> 01:00:55.940
auf der kompletten Tabelle.

01:00:56.600 --> 01:00:57.660
Also auf allen Nutzern.

01:00:58.020 --> 01:00:58.260
Ja,

01:00:58.340 --> 01:00:58.480
genau,

01:00:58.560 --> 01:00:59.140
auf allen Nutzern,

01:00:59.200 --> 01:01:00.760
oder ich möchte einen neuen Nutzer erzeugen.

01:01:01.520 --> 01:01:01.680
Ja,

01:01:01.680 --> 01:01:03.740
das kann ich ja jetzt nicht innerhalb von einem Nutzer machen,

01:01:03.860 --> 01:01:04.920
sondern das ist halt irgendwie,

01:01:05.500 --> 01:01:05.660
ja,

01:01:05.780 --> 01:01:06.240
und dafür,

01:01:06.440 --> 01:01:06.900
äh,

01:01:07.160 --> 01:01:07.700
sag ich dann,

01:01:08.160 --> 01:01:08.940
irgendwas,

01:01:09.220 --> 01:01:09.500
äh,

01:01:09.580 --> 01:01:09.860
Users,

01:01:09.860 --> 01:01:10.080
äh,

01:01:10.080 --> 01:01:10.940
Users Create,

01:01:11.060 --> 01:01:12.700
und das ist dann halt eine Class Method,

01:01:13.300 --> 01:01:14.740
die zwar sozusagen,

01:01:15.040 --> 01:01:15.260
ja,

01:01:15.740 --> 01:01:16.860
Informationen über die Klasse braucht,

01:01:17.080 --> 01:01:17.820
und wissen muss,

01:01:17.860 --> 01:01:18.520
was man dann so tut,

01:01:18.520 --> 01:01:18.780
äh,

01:01:18.780 --> 01:01:19.740
also Users von Create.

01:01:19.860 --> 01:01:20.700
Streng genommen ist es,

01:01:20.780 --> 01:01:21.040
äh,

01:01:21.260 --> 01:01:21.520
naja,

01:01:21.620 --> 01:01:22.240
Objects Create,

01:01:22.360 --> 01:01:22.460
äh,

01:01:22.460 --> 01:01:22.920
das ist halt der,

01:01:22.920 --> 01:01:23.860
der Model Manager,

01:01:24.040 --> 01:01:24.740
auf den man das aufruft,

01:01:24.800 --> 01:01:26.300
aber das ist halt dann ein,

01:01:26.300 --> 01:01:26.800
ein Ding,

01:01:26.940 --> 01:01:28.040
aber dieses Objects ist halt,

01:01:28.060 --> 01:01:28.080
ja,

01:01:28.080 --> 01:01:31.080
das ist ein bisschen komplizierter,

01:01:31.120 --> 01:01:32.260
aber dieses Objects ist auf jeden Fall,

01:01:32.460 --> 01:01:32.720
äh,

01:01:32.880 --> 01:01:33.280
ein Ding,

01:01:33.380 --> 01:01:34.180
was an der Klasse hängt,

01:01:34.780 --> 01:01:34.980
von,

01:01:35.200 --> 01:01:35.500
äh,

01:01:35.500 --> 01:01:36.120
an der,

01:01:36.560 --> 01:01:37.040
und,

01:01:37.220 --> 01:01:38.580
ähm,

01:01:39.580 --> 01:01:40.060
äh,

01:01:40.100 --> 01:01:40.880
äh,

01:01:40.880 --> 01:01:41.560
ja,

01:01:41.740 --> 01:01:42.540
was halt sozusagen,

01:01:43.040 --> 01:01:43.820
also man kann sich das so vorstellen,

01:01:43.920 --> 01:01:45.160
es betrifft halt die gesamte Tabelle,

01:01:45.160 --> 01:01:47.260
man erzeugt jetzt auf dieser Tabelle eine neue Zeile,

01:01:47.320 --> 01:01:48.860
und das kann nicht eine Methode sein,

01:01:48.920 --> 01:01:50.020
die man auf einer Instanz aufruft,

01:01:50.100 --> 01:01:50.260
sondern,

01:01:50.380 --> 01:01:52.080
die halt Instanz und die eine Teile repräsentiert,

01:01:52.160 --> 01:01:52.280
weil,

01:01:52.280 --> 01:01:52.340
ja,

01:01:52.340 --> 01:01:54.060
innerhalb von der einen Zeile sich selber irgendwie,

01:01:54.500 --> 01:01:55.700
ranzuhängen würde gar nicht so richtig funktionieren.

01:01:55.720 --> 01:01:55.820
Ja,

01:01:55.880 --> 01:01:56.480
könnte man auch machen,

01:01:56.540 --> 01:01:56.640
wäre,

01:01:56.680 --> 01:01:57.500
wäre irgendwie komisch,

01:01:57.720 --> 01:01:57.980
ähm,

01:01:57.980 --> 01:01:58.220
und,

01:01:58.300 --> 01:01:58.980
warum nimmt man das aber?

01:01:59.060 --> 01:02:00.260
Dafür ist nicht einfach eine Static Method.

01:02:01.160 --> 01:02:01.340
Ja,

01:02:01.660 --> 01:02:02.260
äh,

01:02:03.340 --> 01:02:04.420
könnte man auch,

01:02:04.520 --> 01:02:04.800
aber,

01:02:04.960 --> 01:02:05.020
das,

01:02:05.140 --> 01:02:05.240
nee,

01:02:05.300 --> 01:02:05.680
kann man nicht,

01:02:05.800 --> 01:02:05.960
weil,

01:02:06.120 --> 01:02:06.340
dann,

01:02:06.720 --> 01:02:08.820
würde man halt zum Beispiel nicht mehr wissen,

01:02:08.820 --> 01:02:10.340
was sind denn jetzt die ganzen Felder,

01:02:10.360 --> 01:02:11.140
die Tabelle wahrscheinlich,

01:02:11.300 --> 01:02:11.440
genau,

01:02:11.540 --> 01:02:12.180
man müsste ja auch wissen,

01:02:12.280 --> 01:02:13.080
welche Attribute gibt es,

01:02:13.140 --> 01:02:13.980
was muss ich eigentlich da,

01:02:14.280 --> 01:02:14.520
und so,

01:02:14.700 --> 01:02:14.720
das,

01:02:15.000 --> 01:02:15.180
ähm,

01:02:15.440 --> 01:02:15.580
ja,

01:02:15.800 --> 01:02:16.400
das muss man ja auch,

01:02:16.460 --> 01:02:17.420
welche Tabelle ist denn das überhaupt,

01:02:17.420 --> 01:02:18.280
wo steht die in der Datenbank,

01:02:18.800 --> 01:02:19.560
und das hängt halt an der,

01:02:19.600 --> 01:02:20.140
das sind Informationen,

01:02:20.280 --> 01:02:21.400
die an der Klasse dranhängen,

01:02:21.640 --> 01:02:21.940
und,

01:02:22.040 --> 01:02:22.340
ähm,

01:02:23.520 --> 01:02:23.740
ja.

01:02:23.880 --> 01:02:24.100
Das heißt,

01:02:24.140 --> 01:02:24.600
die Static Method,

01:02:24.700 --> 01:02:25.420
ich würde mir sowas sagen,

01:02:25.500 --> 01:02:25.660
wie,

01:02:25.820 --> 01:02:26.060
ähm,

01:02:26.460 --> 01:02:28.620
ist da draußen denn was anderes noch verfügbar,

01:02:28.700 --> 01:02:29.560
das könnte ich dann vielleicht gucken?

01:02:29.680 --> 01:02:31.140
Static Method könnte sowas sein,

01:02:31.140 --> 01:02:31.260
wie,

01:02:31.360 --> 01:02:32.240
hash mir mal das Passwort,

01:02:32.920 --> 01:02:33.060
ja,

01:02:33.160 --> 01:02:33.920
also hier hast du einen String,

01:02:34.100 --> 01:02:34.900
mach mir mal einen Hash davon,

01:02:34.980 --> 01:02:36.460
den ich dann irgendwie in die Datenbank schreibe.

01:02:36.620 --> 01:02:36.720
Mhm.

01:02:37.200 --> 01:02:37.380
Da,

01:02:37.480 --> 01:02:38.560
das braucht gar keinen Kontext,

01:02:38.660 --> 01:02:38.700
ja,

01:02:38.740 --> 01:02:39.740
das nimmt irgendwie einen String,

01:02:39.880 --> 01:02:40.980
und gibt einen anderen String raus,

01:02:41.080 --> 01:02:43.020
das braucht aber sonst überhaupt nichts zu wissen,

01:02:43.020 --> 01:02:45.480
und das könnte dann eine Static Method sein,

01:02:45.520 --> 01:02:45.860
zum Beispiel.

01:02:46.120 --> 01:02:48.400
Aber es gehört halt logisch vielleicht schon in die User-Klasse,

01:02:48.520 --> 01:02:50.680
weil es halt irgendwie um Passwörter geht,

01:02:50.780 --> 01:02:50.920
die,

01:02:51.040 --> 01:02:51.320
äh,

01:02:51.560 --> 01:02:52.160
ein User eingibt,

01:02:52.220 --> 01:02:53.500
und die dann halt irgendwie gehasht werden sollen.

01:02:53.940 --> 01:02:54.080
Also,

01:02:54.300 --> 01:02:54.500
das,

01:02:54.720 --> 01:02:55.300
so könnte man das machen.

01:02:55.300 --> 01:02:55.600
Jetzt haben wir noch Property.

01:02:56.420 --> 01:02:56.700
Äh,

01:02:56.780 --> 01:02:57.580
Property-Dekorator,

01:02:57.660 --> 01:02:57.760
ja,

01:02:57.840 --> 01:02:58.140
der ist,

01:02:59.400 --> 01:02:59.660
äh,

01:02:59.660 --> 01:03:01.180
da geht's eigentlich nur darum,

01:03:01.320 --> 01:03:01.700
dass man,

01:03:02.420 --> 01:03:02.840
ähm,

01:03:03.760 --> 01:03:03.880
ja,

01:03:03.940 --> 01:03:04.700
so ein bisschen Convenience,

01:03:04.760 --> 01:03:06.460
dass man dann nicht eine Methode aufruft,

01:03:06.540 --> 01:03:06.840
sondern,

01:03:07.520 --> 01:03:07.840
also man,

01:03:07.840 --> 01:03:08.480
man schreibt halt,

01:03:08.940 --> 01:03:08.960
äh,

01:03:09.000 --> 01:03:10.300
also der häufigste Fall ist,

01:03:10.360 --> 01:03:10.640
man hat,

01:03:10.760 --> 01:03:10.920
äh,

01:03:10.920 --> 01:03:11.480
eine Methode,

01:03:11.480 --> 01:03:13.520
die nennt man so wie ein Attribut,

01:03:13.600 --> 01:03:15.000
und schreibt dann AddProperty drüber,

01:03:15.720 --> 01:03:16.140
äh,

01:03:16.240 --> 01:03:16.900
und dann,

01:03:17.080 --> 01:03:17.280
äh,

01:03:17.320 --> 01:03:18.860
wird halt diese Methode aufgerufen,

01:03:18.980 --> 01:03:19.800
wenn man irgendwo sagt,

01:03:19.880 --> 01:03:20.320
Instanz.

01:03:20.700 --> 01:03:20.840
Punkt,

01:03:21.040 --> 01:03:21.440
äh,

01:03:21.720 --> 01:03:22.480
Also braucht man eigentlich nicht,

01:03:22.520 --> 01:03:23.760
man könnte auch eine Methode schreiben.

01:03:24.620 --> 01:03:24.940
Ja,

01:03:25.020 --> 01:03:26.360
aber dann müsste man halt dann an der Stelle,

01:03:26.420 --> 01:03:26.860
wo man es,

01:03:26.980 --> 01:03:27.140
äh,

01:03:27.160 --> 01:03:27.820
verwenden will,

01:03:27.980 --> 01:03:28.180
äh,

01:03:28.200 --> 01:03:29.240
Klammer auf Klammer zusagen,

01:03:29.600 --> 01:03:30.780
was halt so ein bisschen sinnlos ist,

01:03:30.780 --> 01:03:32.120
wenn man zum Beispiel gar nichts übergeben möchte,

01:03:32.460 --> 01:03:32.620
äh,

01:03:32.660 --> 01:03:33.260
Argumenten,

01:03:33.980 --> 01:03:34.340
und,

01:03:34.460 --> 01:03:34.780
ähm,

01:03:35.580 --> 01:03:36.300
vielleicht auch etwas ist,

01:03:36.360 --> 01:03:36.740
was halt,

01:03:36.820 --> 01:03:37.040
äh,

01:03:37.080 --> 01:03:37.620
so aussehen soll,

01:03:37.700 --> 01:03:38.520
als wäre es ein Attribut,

01:03:38.520 --> 01:03:40.400
aber wo man Sachen noch ausrechnen will,

01:03:40.520 --> 01:03:40.780
und dann,

01:03:40.840 --> 01:03:43.200
kann man halt den Property-Dekorator benutzen,

01:03:43.300 --> 01:03:43.640
um halt,

01:03:43.800 --> 01:03:44.060
ähm,

01:03:44.140 --> 01:03:44.280
Oh,

01:03:44.320 --> 01:03:46.340
das ist quasi ein getarntes Methodending.

01:03:46.420 --> 01:03:46.580
Ja,

01:03:46.920 --> 01:03:47.900
ist so manchmal ein bisschen,

01:03:48.360 --> 01:03:49.260
also das ist auch so,

01:03:49.360 --> 01:03:49.500
so,

01:03:50.980 --> 01:03:53.380
diese Dekorator-Geschichte ist so manchmal ein bisschen,

01:03:54.700 --> 01:03:55.100
ähm,

01:03:55.480 --> 01:03:55.700
also,

01:03:55.920 --> 01:03:55.980
im,

01:03:56.060 --> 01:03:57.300
auf Python steht ja sowas,

01:03:57.380 --> 01:03:58.620
explizit ist besser als implizit,

01:03:58.680 --> 01:03:58.760
ne,

01:03:58.800 --> 01:04:00.340
und das ist halt schon ganz schön implizit,

01:04:00.900 --> 01:04:02.200
dass wenn man jetzt irgendwo,

01:04:02.560 --> 01:04:03.440
äh,

01:04:03.540 --> 01:04:04.040
eben,

01:04:04.780 --> 01:04:05.420
Instanz,

01:04:05.600 --> 01:04:05.980
äh,

01:04:06.060 --> 01:04:06.340
X.

01:04:06.340 --> 01:04:07.540
Punkt Huber sagt,

01:04:07.700 --> 01:04:08.500
halt dann irgendwie,

01:04:08.520 --> 01:04:09.340
ein Code ausgeführt wird,

01:04:09.420 --> 01:04:10.100
der irgendwas ausrechnet,

01:04:10.260 --> 01:04:11.620
und dann unter Umständen auch sehr langsam sein kann,

01:04:11.680 --> 01:04:12.000
oder was auch immer,

01:04:12.280 --> 01:04:12.980
das ist halt nicht unbedingt,

01:04:13.180 --> 01:04:13.740
also in dem Moment,

01:04:13.780 --> 01:04:14.960
wo man das halt lokal liest,

01:04:16.140 --> 01:04:16.880
weiß man nicht,

01:04:16.940 --> 01:04:17.360
was passiert,

01:04:17.520 --> 01:04:18.680
was immer so ein bisschen schlecht ist,

01:04:18.740 --> 01:04:18.820
ne,

01:04:18.840 --> 01:04:19.100
aber,

01:04:19.380 --> 01:04:20.280
ähm,

01:04:20.800 --> 01:04:21.020
ja,

01:04:21.100 --> 01:04:22.340
es ist eigentlich normalerweise,

01:04:22.600 --> 01:04:24.120
wenn man dann komplizierte Sachen macht,

01:04:24.260 --> 01:04:26.580
dann sollte man das vielleicht dann auch eher als Methode hinschreiben,

01:04:27.080 --> 01:04:27.540
und dann,

01:04:27.640 --> 01:04:28.060
äh,

01:04:28.160 --> 01:04:29.380
wird das dann vielleicht klarer,

01:04:29.420 --> 01:04:29.540
ja,

01:04:29.600 --> 01:04:29.740
also.

01:04:29.760 --> 01:04:30.680
Aber wenn man kurz vielleicht,

01:04:30.720 --> 01:04:30.920
äh,

01:04:31.020 --> 01:04:31.920
zwei Attribute hat,

01:04:32.000 --> 01:04:33.180
wie das eine ist Kosten,

01:04:33.180 --> 01:04:34.620
das andere ist Umsatz,

01:04:35.060 --> 01:04:36.400
und dann will man den Gewinn ausrechnen,

01:04:36.400 --> 01:04:37.900
und dann kann man vielleicht schon eine Funktion machen,

01:04:38.000 --> 01:04:39.080
die dann einfach kurz als,

01:04:39.180 --> 01:04:39.580
äh,

01:04:39.580 --> 01:04:40.540
Property sagt hier,

01:04:40.660 --> 01:04:40.860
äh,

01:04:41.200 --> 01:04:41.640
Umsatz,

01:04:41.740 --> 01:04:41.900
äh,

01:04:41.900 --> 01:04:42.160
Gewinn,

01:04:42.280 --> 01:04:42.560
und dann,

01:04:42.660 --> 01:04:42.800
genau.

01:04:43.520 --> 01:04:43.700
Und,

01:04:43.840 --> 01:04:44.160
ähm,

01:04:44.380 --> 01:04:44.540
ja,

01:04:44.680 --> 01:04:44.860
also,

01:04:45.000 --> 01:04:45.400
äh,

01:04:45.400 --> 01:04:45.620
man,

01:04:45.760 --> 01:04:46.060
und das,

01:04:46.320 --> 01:04:47.420
also das Get,

01:04:47.540 --> 01:04:47.740
äh,

01:04:47.740 --> 01:04:48.780
zu implementieren ist ja sehr leicht,

01:04:48.820 --> 01:04:49.880
man schreibt irgendwie der Property drüber,

01:04:49.960 --> 01:04:50.360
und dann war's das.

01:04:50.840 --> 01:04:51.000
Äh,

01:04:51.040 --> 01:04:51.960
das Set geht auch,

01:04:52.040 --> 01:04:52.820
also man kann das auch so machen,

01:04:52.900 --> 01:04:54.340
dass dann halt ein Setter aufgerufen wird,

01:04:54.400 --> 01:04:55.380
wenn man sagt irgendwas,

01:04:55.380 --> 01:04:57.520
in Instance X.fuba gleich irgendwie,

01:04:58.360 --> 01:04:59.300
das ist ein bisschen komplizierter,

01:04:59.940 --> 01:05:00.120
aber,

01:05:00.340 --> 01:05:00.560
äh,

01:05:00.700 --> 01:05:00.900
ja,

01:05:01.100 --> 01:05:01.840
geht auch so ähnlich,

01:05:02.620 --> 01:05:03.080
ähm,

01:05:06.400 --> 01:05:07.260
kann man irgendwie sagen,

01:05:07.380 --> 01:05:07.420
so,

01:05:07.460 --> 01:05:08.020
das ist hier der Getter,

01:05:08.100 --> 01:05:08.800
das ist hier der Setter,

01:05:08.900 --> 01:05:09.200
oder was,

01:05:09.260 --> 01:05:09.420
ach,

01:05:09.420 --> 01:05:09.940
ich weiß nicht genau.

01:05:10.080 --> 01:05:10.860
Kann man dann nachgucken,

01:05:10.900 --> 01:05:11.200
wenn man's braucht.

01:05:11.260 --> 01:05:12.580
Braucht man selten.

01:05:12.720 --> 01:05:14.320
Also ich hab's ein paar Mal benutzt,

01:05:14.400 --> 01:05:15.140
aber nicht oft.

01:05:16.300 --> 01:05:16.560
Aber,

01:05:16.740 --> 01:05:16.940
äh,

01:05:16.960 --> 01:05:17.840
überhaupt das Konzept von,

01:05:17.920 --> 01:05:18.600
von Dekoratoren.

01:05:18.620 --> 01:05:19.120
Das ist immer ganz gut.

01:05:19.180 --> 01:05:20.120
Getter Setter bedeutet halt,

01:05:20.180 --> 01:05:22.400
dass man die Attribute irgendwie von außen dann beeinflussen,

01:05:22.500 --> 01:05:22.740
setzen,

01:05:22.740 --> 01:05:24.000
von der Instanz setzt,

01:05:24.620 --> 01:05:25.020
äh,

01:05:25.200 --> 01:05:26.120
bekommt oder setzt,

01:05:26.300 --> 01:05:26.560
äh,

01:05:26.960 --> 01:05:27.140
genau,

01:05:27.280 --> 01:05:28.620
und zwar nicht direkt manipuliert,

01:05:28.660 --> 01:05:28.860
sondern,

01:05:29.040 --> 01:05:30.200
halt,

01:05:30.360 --> 01:05:30.620
äh,

01:05:30.680 --> 01:05:31.560
Methoden dafür aufruft,

01:05:31.560 --> 01:05:33.020
die dann noch irgendwas vorher und hinterher tun.

01:05:33.040 --> 01:05:34.720
Jetzt haben wir schon ungefähr 50 Mal Dekorator gesagt,

01:05:34.800 --> 01:05:35.920
und du wolltest eigentlich noch irgendwas anderes,

01:05:36.000 --> 01:05:36.560
ähm,

01:05:36.720 --> 01:05:36.920
vorher sagen.

01:05:36.920 --> 01:05:37.760
Dann muss man vielleicht nochmal erklären,

01:05:37.820 --> 01:05:39.000
was ein Dekorator eigentlich ist.

01:05:39.300 --> 01:05:40.200
Eigentlich ist es eine sehr,

01:05:40.480 --> 01:05:40.700
äh,

01:05:40.940 --> 01:05:41.460
nicht so,

01:05:41.620 --> 01:05:41.920
äh,

01:05:42.000 --> 01:05:42.560
nicht so,

01:05:42.720 --> 01:05:43.220
äh,

01:05:43.860 --> 01:05:44.060
na,

01:05:44.320 --> 01:05:45.040
es kann,

01:05:45.140 --> 01:05:46.520
es kann leicht kompliziert werden.

01:05:46.580 --> 01:05:46.980
Trick, Trick.

01:05:48.280 --> 01:05:48.560
Äh,

01:05:48.660 --> 01:05:48.820
ja,

01:05:48.860 --> 01:05:51.180
es ist auf der einen Seite ein bisschen Spezialsyntax,

01:05:51.520 --> 01:05:52.140
ähm,

01:05:52.400 --> 01:05:52.580
äh,

01:05:52.620 --> 01:05:53.700
diese Geschichte mit dem Ad-Symbol,

01:05:53.780 --> 01:05:56.740
dass man halt über Klassen und über Methoden,

01:05:56.820 --> 01:05:57.780
Funktionen schreiben kann,

01:05:58.040 --> 01:05:58.560
äh,

01:05:58.760 --> 01:06:00.280
auf der anderen Seite ist es,

01:06:00.280 --> 01:06:00.760
ähm,

01:06:01.100 --> 01:06:01.500
man könnte es,

01:06:01.560 --> 01:06:02.240
so anders hinschreiben,

01:06:02.800 --> 01:06:04.360
und da bräuchte man diese Spezialsyntax nicht,

01:06:04.500 --> 01:06:06.420
also die haben das so ein bisschen vereinfacht,

01:06:06.420 --> 01:06:07.640
man könnte halt auch hinschreiben,

01:06:08.620 --> 01:06:08.900
äh,

01:06:09.080 --> 01:06:10.380
irgendwie x gleich,

01:06:10.640 --> 01:06:11.420
ähm,

01:06:12.460 --> 01:06:13.760
wrap mir mal eine andere Funktion,

01:06:13.800 --> 01:06:14.060
wrap,

01:06:14.180 --> 01:06:14.740
Klammer auf,

01:06:14.880 --> 01:06:15.720
irgendwie eine andere Funktion,

01:06:15.860 --> 01:06:16.300
Klammer zu,

01:06:17.080 --> 01:06:18.320
und dann wäre das die dekorierte,

01:06:18.460 --> 01:06:18.620
ja,

01:06:18.700 --> 01:06:19.660
x die dekorierte Funktion,

01:06:19.880 --> 01:06:20.100
also,

01:06:20.740 --> 01:06:21.020
äh,

01:06:21.060 --> 01:06:22.460
man macht sich eine Tapete auf die Wand,

01:06:22.540 --> 01:06:24.780
und unter der sieht man dann halt hier Sachen anders.

01:06:25.740 --> 01:06:25.860
Ah,

01:06:25.900 --> 01:06:26.620
die Form bleibt erhalten,

01:06:26.700 --> 01:06:27.960
damit ist dann vielleicht rot oder blau.

01:06:28.600 --> 01:06:28.860
Ja,

01:06:29.040 --> 01:06:29.260
äh,

01:06:29.300 --> 01:06:30.380
also die Idee ist sozusagen,

01:06:30.520 --> 01:06:30.900
dass man,

01:06:31.180 --> 01:06:31.500
äh,

01:06:31.560 --> 01:06:33.560
äh,

01:06:34.500 --> 01:06:35.500
etwas macht,

01:06:35.660 --> 01:06:36.620
also man halt Code hat,

01:06:36.880 --> 01:06:37.120
der,

01:06:38.200 --> 01:06:38.620
ja,

01:06:38.680 --> 01:06:39.360
man packt,

01:06:39.540 --> 01:06:40.860
deswegen ist Dekorator eigentlich auch ein,

01:06:40.960 --> 01:06:42.120
der zeichnet ziemlich genau,

01:06:42.200 --> 01:06:42.540
was es tut,

01:06:43.280 --> 01:06:43.760
äh,

01:06:44.060 --> 01:06:44.440
man hat halt,

01:06:44.460 --> 01:06:44.980
Code und Output,

01:06:45.100 --> 01:06:45.940
der rauskommt,

01:06:46.040 --> 01:06:46.920
oder beziehungsweise reingeht,

01:06:47.000 --> 01:06:47.220
wird,

01:06:47.640 --> 01:06:48.040
wird nochmal,

01:06:48.180 --> 01:06:49.200
geht nochmal durch anderen Code durch,

01:06:49.480 --> 01:06:50.180
und dann,

01:06:50.460 --> 01:06:51.900
äh,

01:06:51.920 --> 01:06:52.760
sozusagen man kann halt,

01:06:52.960 --> 01:06:53.540
bevor irgendwas,

01:06:53.780 --> 01:06:54.920
bevor die Funktion aufgerufen wird,

01:06:54.980 --> 01:06:56.060
irgendwie Dinge damit tun,

01:06:56.360 --> 01:06:56.580
und,

01:06:56.660 --> 01:06:56.980
ähm,

01:06:57.540 --> 01:06:58.860
hinterher Dinge mit dem,

01:06:59.120 --> 01:06:59.880
das wird aber langsam,

01:06:59.880 --> 01:07:01.040
wenn das durch einen Dekorator hat,

01:07:01.100 --> 01:07:01.540
der einen Dekorator,

01:07:01.560 --> 01:07:01.800
hat,

01:07:01.820 --> 01:07:02.580
der einen Dekorator hat,

01:07:02.600 --> 01:07:02.680
dann,

01:07:02.860 --> 01:07:03.840
ja,

01:07:04.100 --> 01:07:05.660
aber normale Funktionsaufrufe,

01:07:05.980 --> 01:07:07.120
macht man ja auch,

01:07:07.260 --> 01:07:07.940
ist auch okay,

01:07:08.180 --> 01:07:08.300
äh,

01:07:08.360 --> 01:07:08.520
also,

01:07:08.740 --> 01:07:08.900
äh,

01:07:08.900 --> 01:07:10.180
und das ist ja auch nichts anderes im Grunde.

01:07:10.360 --> 01:07:10.660
Das heißt,

01:07:10.700 --> 01:07:11.740
wenn man einen Dekorator selber schreibt,

01:07:11.840 --> 01:07:12.980
dann baut man quasi einen eigenen Rapper,

01:07:13.100 --> 01:07:13.440
und sagt halt,

01:07:13.480 --> 01:07:13.800
was passiert,

01:07:13.900 --> 01:07:14.620
bevor der da reingeht,

01:07:14.680 --> 01:07:15.560
und wann der wieder rauskommt.

01:07:16.660 --> 01:07:16.860
Ja,

01:07:16.980 --> 01:07:17.580
man sollte auch,

01:07:17.740 --> 01:07:19.100
ähm,

01:07:19.260 --> 01:07:19.420
äh,

01:07:19.460 --> 01:07:19.860
tatsächlich,

01:07:20.120 --> 01:07:20.680
äh,

01:07:20.960 --> 01:07:21.560
genau,

01:07:21.740 --> 01:07:21.900
äh,

01:07:21.900 --> 01:07:22.100
nicht,

01:07:22.260 --> 01:07:22.700
nicht wirklich,

01:07:22.780 --> 01:07:23.540
wenn man Dekoratoren schreibt,

01:07:23.540 --> 01:07:23.820
nicht,

01:07:23.980 --> 01:07:25.420
das selber machen eigentlich,

01:07:25.540 --> 01:07:26.160
sondern man sollte aus,

01:07:26.240 --> 01:07:26.960
für den Funktools,

01:07:26.960 --> 01:07:27.400
Raps,

01:07:27.520 --> 01:07:28.080
oder so nehmen,

01:07:28.180 --> 01:07:28.420
nehmen,

01:07:29.120 --> 01:07:29.660
und,

01:07:29.780 --> 01:07:30.120
ähm,

01:07:30.320 --> 01:07:30.620
weil,

01:07:30.980 --> 01:07:32.340
es gibt noch so ein paar Hakeligkeiten,

01:07:32.500 --> 01:07:33.780
mit den Funktionsnamen,

01:07:33.800 --> 01:07:34.220
zum Beispiel,

01:07:34.340 --> 01:07:35.100
die sonst verschwinden,

01:07:35.240 --> 01:07:35.480
wenn man,

01:07:35.980 --> 01:07:37.260
die sieht man in Tracebacks nicht mehr,

01:07:37.480 --> 01:07:38.440
und da muss man so ein bisschen,

01:07:38.880 --> 01:07:39.480
und dann gibt's halt,

01:07:39.700 --> 01:07:39.980
ähm,

01:07:40.220 --> 01:07:41.200
eben in den Funktools,

01:07:41.340 --> 01:07:41.920
gibt's da,

01:07:41.980 --> 01:07:42.360
glaube ich,

01:07:42.480 --> 01:07:43.000
äh,

01:07:43.080 --> 01:07:43.440
irgendwie,

01:07:43.700 --> 01:07:44.600
ähm,

01:07:44.940 --> 01:07:45.220
ähm,

01:07:45.500 --> 01:07:46.200
Funktionen,

01:07:46.200 --> 01:07:46.340
die,

01:07:46.440 --> 01:07:47.080
wenn man die benutzt,

01:07:47.120 --> 01:07:48.140
um den Dekorator zu bauen,

01:07:48.240 --> 01:07:49.480
dann kümmern die sich um diesen Kram,

01:07:49.600 --> 01:07:50.180
sodass halt dann,

01:07:50.200 --> 01:07:51.520
wenn man Tracebacks weiter in die Namen sieht,

01:07:51.580 --> 01:07:51.740
und so,

01:07:51.800 --> 01:07:52.240
also das ist ein bisschen,

01:07:52.240 --> 01:07:53.960
das hat das jetzt mit so einem Kontext zu tun,

01:07:54.040 --> 01:07:54.720
Kontextmanager,

01:07:54.820 --> 01:07:55.060
oder so was,

01:07:55.080 --> 01:07:55.160
das ist,

01:07:55.180 --> 01:07:55.300
oh,

01:07:55.400 --> 01:07:55.560
nee,

01:07:55.700 --> 01:07:56.720
das hat aber nichts zu tun,

01:07:56.820 --> 01:07:57.580
das ist so eine arme Geschichte,

01:07:58.500 --> 01:07:59.520
das hört sich so ein bisschen an,

01:07:59.560 --> 01:08:00.780
als macht man irgendwie so einen Kontext auf,

01:08:00.800 --> 01:08:01.300
und rappt irgendwas,

01:08:01.420 --> 01:08:02.000
und gibt das dann wieder,

01:08:02.220 --> 01:08:03.460
baut das dann am Ende wieder auseinander,

01:08:04.260 --> 01:08:06.300
mhm,

01:08:06.460 --> 01:08:06.660
also,

01:08:06.900 --> 01:08:07.800
ja,

01:08:08.860 --> 01:08:09.100
also,

01:08:09.180 --> 01:08:10.560
was eventuell irgendwie,

01:08:12.100 --> 01:08:13.500
eine Gemeinsamkeit ist,

01:08:13.500 --> 01:08:14.760
dass beides irgendwie unten drunter,

01:08:15.040 --> 01:08:16.080
vielleicht Closure ist verwendet,

01:08:16.140 --> 01:08:16.480
als,

01:08:16.640 --> 01:08:16.900
äh,

01:08:16.900 --> 01:08:17.840
wie das umgesetzt ist,

01:08:17.900 --> 01:08:18.200
aber,

01:08:18.540 --> 01:08:18.820
äh,

01:08:18.820 --> 01:08:19.700
ja,

01:08:20.060 --> 01:08:20.840
das ist sozusagen eine,

01:08:20.840 --> 01:08:21.540
mhm,

01:08:21.780 --> 01:08:22.060
eine,

01:08:22.060 --> 01:08:22.080
eine,

01:08:22.080 --> 01:08:22.100
eine,

01:08:22.100 --> 01:08:22.120
eine,

01:08:22.120 --> 01:08:22.840
eine interne Funktion,

01:08:22.960 --> 01:08:23.280
die halt,

01:08:23.360 --> 01:08:23.640
äh,

01:08:24.300 --> 01:08:25.120
zurückgegeben wird,

01:08:26.260 --> 01:08:27.660
und die halt,

01:08:27.720 --> 01:08:28.340
das ist ja auch so der Trick,

01:08:28.400 --> 01:08:29.100
wie man das hinkriegt,

01:08:29.180 --> 01:08:29.540
dass der,

01:08:29.760 --> 01:08:30.000
äh,

01:08:30.080 --> 01:08:30.500
Scope,

01:08:30.740 --> 01:08:31.040
äh,

01:08:31.160 --> 01:08:33.280
dass man halt auf die Sachen zugreifen kann,

01:08:33.520 --> 01:08:34.780
die im Scope der Funktion sind,

01:08:35.200 --> 01:08:36.200
dass man halt sozusagen,

01:08:36.580 --> 01:08:37.240
äh,

01:08:38.220 --> 01:08:38.540
äh,

01:08:38.600 --> 01:08:38.760
naja,

01:08:38.780 --> 01:08:39.440
das ist zu kompliziert,

01:08:39.500 --> 01:08:40.220
das kann man alles nicht so,

01:08:40.280 --> 01:08:41.200
das ist auch nicht anfängermäßig,

01:08:41.240 --> 01:08:42.020
das kann man nicht gut erklären,

01:08:42.420 --> 01:08:43.340
da muss man sich einfach mal,

01:08:43.520 --> 01:08:43.680
äh,

01:08:43.740 --> 01:08:44.180
also ich würde sagen,

01:08:44.240 --> 01:08:44.800
also ein Tipp ist,

01:08:44.920 --> 01:08:45.260
äh,

01:08:45.620 --> 01:08:46.040
sich das,

01:08:46.040 --> 01:08:46.460
wenn man,

01:08:46.460 --> 01:08:47.860
wenn man die Kraton schreiben will,

01:08:47.980 --> 01:08:48.220
äh,

01:08:48.220 --> 01:08:48.360
äh,

01:08:48.440 --> 01:08:49.080
aus den Functools,

01:08:49.180 --> 01:08:49.560
äh,

01:08:49.660 --> 01:08:51.560
die Reps-Funktion zu nehmen,

01:08:51.860 --> 01:08:52.300
und,

01:08:52.420 --> 01:08:52.760
ähm,

01:08:52.880 --> 01:08:53.040
ja,

01:08:53.560 --> 01:08:55.560
einfach mal so ein bisschen damit rumzuspielen,

01:08:55.640 --> 01:08:56.260
man braucht ein bisschen,

01:08:56.380 --> 01:08:57.120
bis das irgendwie,

01:08:57.360 --> 01:08:57.580
äh,

01:08:58.040 --> 01:08:58.980
bis man das so raus hat,

01:08:59.680 --> 01:09:00.380
ja,

01:09:00.740 --> 01:09:01.140
ähm,

01:09:02.520 --> 01:09:02.780
genau,

01:09:02.900 --> 01:09:03.920
aber dafür sind Dekoratoren da,

01:09:04.000 --> 01:09:04.120
also,

01:09:04.540 --> 01:09:06.040
man kann damit ganz nette Sachen machen,

01:09:06.140 --> 01:09:06.760
wie zum Beispiel,

01:09:07.760 --> 01:09:07.980
also,

01:09:08.060 --> 01:09:08.840
wenn man einfach nur wissen will,

01:09:08.920 --> 01:09:10.320
wofür braucht man solche Sachen eigentlich,

01:09:10.560 --> 01:09:10.860
äh,

01:09:11.060 --> 01:09:11.620
wenn man,

01:09:11.940 --> 01:09:12.260
ähm,

01:09:12.960 --> 01:09:13.120
ja,

01:09:13.120 --> 01:09:14.480
zum Beispiel eben wieder Datenbankgeschichte,

01:09:14.780 --> 01:09:15.380
kann man sagen,

01:09:15.540 --> 01:09:15.680
okay,

01:09:16.340 --> 01:09:16.520
äh,

01:09:16.520 --> 01:09:17.120
gibt's einen Transaktionsdekorator,

01:09:17.860 --> 01:09:17.940
ne,

01:09:17.960 --> 01:09:18.100
da,

01:09:18.140 --> 01:09:18.160
da,

01:09:18.220 --> 01:09:19.080
schreibt man einfach drüber,

01:09:19.360 --> 01:09:19.660
äh,

01:09:19.680 --> 01:09:20.960
Transaction Atomic,

01:09:21.180 --> 01:09:21.480
genau,

01:09:22.320 --> 01:09:24.200
das hier ist jetzt alles in einer Transaktion,

01:09:24.320 --> 01:09:24.480
und das,

01:09:24.620 --> 01:09:26.060
alle Schritte gehen zusammen gut,

01:09:26.100 --> 01:09:26.660
oder gar nicht,

01:09:26.680 --> 01:09:27.980
und wenn halt zwischendurch irgendwas,

01:09:28.760 --> 01:09:28.980
äh,

01:09:29.020 --> 01:09:29.820
nicht funktioniert hat,

01:09:29.900 --> 01:09:32.860
dann rollt das automatisch die Datenbank in den ursprünglichen Zustand zurück,

01:09:32.920 --> 01:09:33.640
als wäre nichts passiert.

01:09:33.720 --> 01:09:34.460
Das ist ein tolles Beispiel,

01:09:34.560 --> 01:09:35.740
weil da gibt's nämlich auch den Kontextmanager,

01:09:35.800 --> 01:09:36.260
man kann auch sagen,

01:09:36.320 --> 01:09:37.520
with a Transaction Atomic,

01:09:37.620 --> 01:09:37.780
ja,

01:09:37.840 --> 01:09:37.960
ja,

01:09:37.960 --> 01:09:38.120
ja,

01:09:38.120 --> 01:09:38.340
genau,

01:09:38.500 --> 01:09:38.660
ja,

01:09:38.780 --> 01:09:39.180
es ist,

01:09:39.300 --> 01:09:39.700
äh,

01:09:39.740 --> 01:09:40.100
klar,

01:09:40.200 --> 01:09:40.680
kann man auch machen,

01:09:40.860 --> 01:09:41.020
ja,

01:09:42.080 --> 01:09:42.880
ähm,

01:09:44.020 --> 01:09:44.220
ja,

01:09:45.160 --> 01:09:45.740
äh,

01:09:46.880 --> 01:09:47.160
das,

01:09:47.340 --> 01:09:47.640
äh,

01:09:47.720 --> 01:09:47.860
genau,

01:09:47.860 --> 01:09:48.340
das ist eine,

01:09:48.420 --> 01:09:48.940
eine Geschichte,

01:09:49.080 --> 01:09:50.560
ansonsten,

01:09:50.860 --> 01:09:51.040
ja,

01:09:51.120 --> 01:09:52.600
man kann auch Dekoratoren dafür benutzen,

01:09:52.720 --> 01:09:55.360
um sich jetzt eine bestimmte Datenbankverwendung immer reinzuholen,

01:09:55.480 --> 01:09:55.860
in eine Funktion,

01:09:56.660 --> 01:09:56.740
ja,

01:09:56.780 --> 01:09:58.080
da werden wir jetzt gerade über Tango reden,

01:09:58.160 --> 01:09:58.920
da wird das ja auch benutzt,

01:09:58.980 --> 01:09:59.520
zum Beispiel für,

01:09:59.580 --> 01:10:00.560
um Funktionen zu dekorieren,

01:10:00.640 --> 01:10:01.280
Login Required,

01:10:01.340 --> 01:10:02.920
dass man halt irgendwie eingeloggt im Benutzer sein muss,

01:10:03.440 --> 01:10:03.860
das heißt,

01:10:04.020 --> 01:10:04.200
ähm,

01:10:04.500 --> 01:10:05.020
die Frage ist halt,

01:10:05.040 --> 01:10:05.680
was er dann macht,

01:10:06.060 --> 01:10:07.320
das kann man auch als Mix-In benutzen,

01:10:07.420 --> 01:10:07.720
das heißt,

01:10:07.940 --> 01:10:10.060
auch das wäre eine ähnliche Methode,

01:10:10.120 --> 01:10:10.960
ein Mix-In ist ein,

01:10:11.020 --> 01:10:11.260
äh,

01:10:11.660 --> 01:10:13.300
Subklasse einer Klasse,

01:10:13.360 --> 01:10:13.860
die man benutzt,

01:10:13.860 --> 01:10:15.460
und bestimmte Attribute zusätzlich dazu.

01:10:15.460 --> 01:10:15.480
Ja,

01:10:15.480 --> 01:10:16.960
Mix-In ist dann so ein bisschen eben,

01:10:17.060 --> 01:10:17.480
wie man,

01:10:17.600 --> 01:10:18.060
äh,

01:10:19.560 --> 01:10:19.900
Code,

01:10:20.080 --> 01:10:20.380
äh,

01:10:20.380 --> 01:10:21.260
wiederverwenden kann,

01:10:22.000 --> 01:10:22.640
in Klassen,

01:10:22.820 --> 01:10:23.780
ohne erben zu müssen,

01:10:23.880 --> 01:10:24.740
weil erben macht natürlich,

01:10:24.840 --> 01:10:26.660
das ist ja sozusagen ein ganz klassischer Weg,

01:10:26.720 --> 01:10:27.580
und das kann man natürlich auch tun.

01:10:27.660 --> 01:10:27.740
Ja,

01:10:27.760 --> 01:10:29.100
also in gewisser Weise ist es ja eine Form von vererben,

01:10:29.200 --> 01:10:30.380
also aber eine generalisierte Form,

01:10:30.480 --> 01:10:33.440
die irgendwie jetzt nicht genau mit der ursprünglichen Klasse zu tun hat,

01:10:33.460 --> 01:10:33.600
sondern,

01:10:33.960 --> 01:10:34.140
ja,

01:10:34.280 --> 01:10:34.440
genau,

01:10:34.540 --> 01:10:35.180
also du kannst halt,

01:10:35.300 --> 01:10:35.740
ist es nicht so,

01:10:35.820 --> 01:10:36.380
dass du,

01:10:36.940 --> 01:10:36.960
äh,

01:10:37.400 --> 01:10:37.540
ja,

01:10:37.620 --> 01:10:38.580
also zwei unterschiedliche Klassen,

01:10:38.680 --> 01:10:39.560
die nichts miteinander zu tun haben,

01:10:39.560 --> 01:10:40.560
ganz unterschiedliche Stellen,

01:10:41.080 --> 01:10:41.280
ähm,

01:10:41.280 --> 01:10:42.320
in der Klassenhierarchie sind,

01:10:42.420 --> 01:10:43.920
können halt das gleiche Mix-In verwenden.

01:10:44.060 --> 01:10:44.700
Das ist cool,

01:10:44.780 --> 01:10:45.380
das ist so ein bisschen wie,

01:10:45.380 --> 01:10:45.940
wie Genetik,

01:10:46.000 --> 01:10:47.300
du kannst dem Frosch Flügel geben,

01:10:47.380 --> 01:10:47.680
oder so.

01:10:48.840 --> 01:10:49.100
Ja.

01:10:50.500 --> 01:10:51.080
Das ist,

01:10:51.720 --> 01:10:51.740
äh,

01:10:52.200 --> 01:10:52.360
ja,

01:10:52.440 --> 01:10:52.640
ja,

01:10:52.720 --> 01:10:53.860
warum auch nicht.

01:10:55.820 --> 01:10:56.180
Ja,

01:10:56.240 --> 01:10:56.800
wenn du Sachen hat,

01:10:56.800 --> 01:10:57.460
die Flügel haben wollen,

01:10:57.520 --> 01:10:58.380
man hat irgendwie eine Klasse,

01:10:58.480 --> 01:10:59.440
die Flügel bereitstellt,

01:10:59.480 --> 01:11:01.040
dann kann man diese Flügel jeder Klasse geben,

01:11:01.120 --> 01:11:01.300
und jetzt.

01:11:01.300 --> 01:11:01.440
Ja,

01:11:02.020 --> 01:11:02.240
ja,

01:11:02.240 --> 01:11:02.400
macht,

01:11:02.460 --> 01:11:04.400
macht natürlich auch nicht immer irgendwie Sinn,

01:11:04.500 --> 01:11:04.700
aber,

01:11:04.880 --> 01:11:05.420
äh,

01:11:05.560 --> 01:11:06.180
also,

01:11:06.180 --> 01:11:06.500
also,

01:11:06.780 --> 01:11:06.900
äh,

01:11:07.240 --> 01:11:08.940
Vererbung ist auch so ein problematisches Geschirr,

01:11:09.020 --> 01:11:09.540
das ist immer das,

01:11:09.540 --> 01:11:09.860
was einem,

01:11:10.000 --> 01:11:10.140
äh,

01:11:10.140 --> 01:11:12.540
wenn man sich mit objektorientierter Programmierung beschäftigt,

01:11:12.620 --> 01:11:13.380
irgendwie so gesagt wird,

01:11:13.420 --> 01:11:14.040
wie man das tun soll,

01:11:14.080 --> 01:11:14.580
oder so am Anfang,

01:11:14.680 --> 01:11:14.920
keine Ahnung,

01:11:15.000 --> 01:11:15.200
jedenfalls,

01:11:15.260 --> 01:11:15.400
weil wir,

01:11:15.460 --> 01:11:16.760
vielleicht ist es mittlerweile auch besser geworden,

01:11:17.360 --> 01:11:17.840
ähm,

01:11:18.000 --> 01:11:19.640
dass man halt Sachen von Dingen dann erbt,

01:11:19.720 --> 01:11:19.800
ne,

01:11:19.840 --> 01:11:20.380
dass man halt,

01:11:20.460 --> 01:11:20.780
äh,

01:11:21.540 --> 01:11:22.080
keine Ahnung,

01:11:22.340 --> 01:11:22.800
äh,

01:11:24.160 --> 01:11:24.380
ja,

01:11:24.660 --> 01:11:24.860
äh,

01:11:24.860 --> 01:11:25.280
weiß ich nicht,

01:11:25.340 --> 01:11:28.060
da wird immer mit solchen Beispielen gearbeitet,

01:11:28.260 --> 01:11:28.480
was,

01:11:29.480 --> 01:11:30.360
äh,

01:11:31.320 --> 01:11:31.900
äh,

01:11:31.900 --> 01:11:31.960
äh,

01:11:31.960 --> 01:11:33.040
dass man,

01:11:33.920 --> 01:11:34.240
irgendwie,

01:11:34.340 --> 01:11:34.680
keine Ahnung,

01:11:34.760 --> 01:11:36.000
meistens irgendwelche geometrischen Formen,

01:11:36.040 --> 01:11:36.480
oder sowas,

01:11:36.560 --> 01:11:36.680
ne,

01:11:37.040 --> 01:11:37.440
irgendwie,

01:11:37.800 --> 01:11:38.260
wenn man jetzt,

01:11:38.340 --> 01:11:38.580
äh,

01:11:38.580 --> 01:11:39.680
ein rechtwinkliges Dreieck hat,

01:11:39.700 --> 01:11:41.440
dann ist das auf jeden Fall schon mal ein Dreieck,

01:11:41.500 --> 01:11:41.580
ne,

01:11:41.600 --> 01:11:42.480
und ein Dreieck ist irgendwas,

01:11:42.580 --> 01:11:43.160
was halt irgendwie,

01:11:43.160 --> 01:11:43.380
ja,

01:11:43.440 --> 01:11:44.080
ich finde das ganz,

01:11:44.080 --> 01:11:44.460
ganz schlecht,

01:11:44.560 --> 01:11:45.700
das nämlich dem Gradius auch vorzustellen,

01:11:45.780 --> 01:11:45.820
ne,

01:11:45.860 --> 01:11:47.380
also die geometrische Formen sind zwar ganz,

01:11:48.020 --> 01:11:48.740
okay,

01:11:48.940 --> 01:11:50.160
aber vielleicht auch mit dieser,

01:11:50.260 --> 01:11:50.760
ähm,

01:11:51.040 --> 01:11:51.740
Universums,

01:11:51.860 --> 01:11:52.060
äh,

01:11:52.060 --> 01:11:52.360
Geschichte,

01:11:52.660 --> 01:11:54.040
du hast irgendwo ein großes,

01:11:54.220 --> 01:11:54.900
schwarzes Loch,

01:11:54.980 --> 01:11:55.540
so den Urknall,

01:11:55.580 --> 01:11:55.940
oder sowas,

01:11:56.220 --> 01:11:57.020
und ein Objekt,

01:11:57.100 --> 01:11:57.320
äh,

01:11:57.320 --> 01:11:58.720
orbitet da irgendwie herum,

01:11:58.900 --> 01:12:00.760
das ist jetzt vielleicht schon mal so eine Galaxie,

01:12:01.280 --> 01:12:01.700
und dann,

01:12:01.880 --> 01:12:02.020
äh,

01:12:02.060 --> 01:12:02.620
das ist also die,

01:12:02.700 --> 01:12:04.220
die Subklasse wäre es halt Universum,

01:12:04.320 --> 01:12:04.400
ne,

01:12:04.400 --> 01:12:05.520
das wäre so die Basisklasse,

01:12:05.640 --> 01:12:06.540
von der alles irgendwie erbt,

01:12:06.600 --> 01:12:07.520
alles ist irgendwie so ein Ding,

01:12:07.720 --> 01:12:08.780
das ist ein bisschen groß,

01:12:09.100 --> 01:12:09.240
ja,

01:12:09.240 --> 01:12:10.200
dann hast du halt eine Galaxie,

01:12:10.280 --> 01:12:11.420
das ist vielleicht schon mal das erste kleine Ding,

01:12:11.520 --> 01:12:11.580
dann,

01:12:11.620 --> 01:12:11.780
oh,

01:12:11.900 --> 01:12:12.020
okay,

01:12:12.140 --> 01:12:13.480
in der Galaxie gibt es ein Sonnensystem,

01:12:13.840 --> 01:12:15.380
ein Sonnensystem ist auf jeden Fall Teil einer Galaxie,

01:12:15.460 --> 01:12:16.500
dann gelten halt die gleichen Gesetze,

01:12:16.600 --> 01:12:17.380
physikalischen Gesetze,

01:12:17.740 --> 01:12:18.360
und hast du ein Sonnensystem,

01:12:18.420 --> 01:12:19.020
hast du einen Planeten,

01:12:19.100 --> 01:12:21.180
das ist jetzt vielleicht schon unsere speziellere Klasse,

01:12:21.700 --> 01:12:22.320
und dann weißt du halt,

01:12:22.400 --> 01:12:22.520
genau,

01:12:22.600 --> 01:12:23.600
das gibt verschiedene Sonnensysteme,

01:12:23.640 --> 01:12:24.240
die haben vielleicht,

01:12:24.280 --> 01:12:24.520
äh,

01:12:24.640 --> 01:12:24.780
ne,

01:12:25.020 --> 01:12:26.060
gleiche Grundlagen,

01:12:26.120 --> 01:12:29.300
und Planeten können jetzt aber verschiedene Dinge besonders machen.

01:12:29.300 --> 01:12:29.660
Äh,

01:12:30.080 --> 01:12:30.300
ja,

01:12:30.320 --> 01:12:30.660
aber ich glaube,

01:12:30.720 --> 01:12:31.200
ich fürchte,

01:12:31.200 --> 01:12:31.420
also,

01:12:31.520 --> 01:12:32.260
das wird auch,

01:12:32.520 --> 01:12:32.700
also,

01:12:32.780 --> 01:12:33.820
mit solchen Dingen,

01:12:34.200 --> 01:12:34.620
ich glaube,

01:12:34.720 --> 01:12:35.360
dass Leute versuchen,

01:12:35.460 --> 01:12:37.440
irgendwie so Alltags-Ontologie,

01:12:37.620 --> 01:12:37.900
irgendwie,

01:12:38.160 --> 01:12:38.700
äh,

01:12:38.780 --> 01:12:40.200
aber das Problem ist,

01:12:40.200 --> 01:12:40.920
das passt ja schon,

01:12:41.000 --> 01:12:41.080
also,

01:12:41.100 --> 01:12:41.920
weil dieser Planet,

01:12:41.960 --> 01:12:42.840
der orbitet ja,

01:12:43.400 --> 01:12:43.540
ne,

01:12:44.000 --> 01:12:44.340
dieser,

01:12:44.720 --> 01:12:45.280
diesem Stern,

01:12:45.600 --> 01:12:46.100
und der Stern,

01:12:46.140 --> 01:12:48.120
der orbitet ja dem Zentrum dieser Galaxis,

01:12:48.260 --> 01:12:48.420
so,

01:12:49.000 --> 01:12:49.200
ja,

01:12:49.320 --> 01:12:51.360
dann wäre sozusagen die allgemeinste Oberklasse,

01:12:51.480 --> 01:12:52.340
wäre sowas wie Himmelskörper,

01:12:52.520 --> 01:12:53.040
oder sowas,

01:12:53.180 --> 01:12:53.840
oder keine Ahnung,

01:12:54.100 --> 01:12:54.300
ne,

01:12:54.340 --> 01:12:54.460
ne,

01:12:54.460 --> 01:12:54.640
ne,

01:12:54.640 --> 01:12:54.780
ne,

01:12:54.780 --> 01:12:55.020
ne,

01:12:55.020 --> 01:12:55.060
ne,

01:12:55.060 --> 01:12:55.080
ne,

01:12:55.080 --> 01:12:55.100
ne,

01:12:55.100 --> 01:12:55.120
ne,

01:12:55.120 --> 01:12:55.420
ich glaube,

01:12:55.520 --> 01:12:55.600
das,

01:12:55.660 --> 01:12:56.600
das ist gar nicht so,

01:12:56.900 --> 01:12:57.040
also,

01:12:57.080 --> 01:12:57.820
Himmelskörper-Objekt,

01:12:57.820 --> 01:12:58.080
na,

01:12:58.200 --> 01:12:58.580
ich weiß nicht,

01:12:59.180 --> 01:12:59.380
also,

01:12:59.480 --> 01:13:00.180
du brauchst ja schon ein Orbit,

01:13:00.240 --> 01:13:00.800
das ist ja Grundeinkommen,

01:13:00.800 --> 01:13:00.940
ja,

01:13:01.000 --> 01:13:01.160
aber,

01:13:01.400 --> 01:13:01.880
aber,

01:13:01.980 --> 01:13:02.500
ich würde nicht,

01:13:02.700 --> 01:13:03.120
ich würde,

01:13:03.240 --> 01:13:03.380
also,

01:13:03.540 --> 01:13:03.660
das,

01:13:03.740 --> 01:13:04.060
ich will immer,

01:13:04.060 --> 01:13:05.220
ich will in die Erbung so ein bisschen gucken,

01:13:05.360 --> 01:13:05.460
oder?

01:13:05.660 --> 01:13:05.940
Ich,

01:13:05.940 --> 01:13:06.280
ich will,

01:13:06.320 --> 01:13:07.020
dass das immer wieder passiert,

01:13:07.100 --> 01:13:07.400
und das soll ich,

01:13:07.460 --> 01:13:07.620
Leute,

01:13:07.800 --> 01:13:08.760
dass das versucht wird,

01:13:08.800 --> 01:13:09.500
das so zu beschreiben,

01:13:09.640 --> 01:13:10.120
und ich finde,

01:13:10.240 --> 01:13:11.220
das ist nicht hilfreich,

01:13:11.340 --> 01:13:11.560
weil,

01:13:12.360 --> 01:13:12.840
ähm,

01:13:12.880 --> 01:13:13.280
das Mond,

01:13:13.340 --> 01:13:13.860
dann geht ein Planet,

01:13:14.140 --> 01:13:16.440
ja,

01:13:16.440 --> 01:13:18.240
du machst ja irgendwie immer so eine Basisklasse,

01:13:18.340 --> 01:13:18.400
ja,

01:13:18.400 --> 01:13:20.020
und die Basisklasse vom Mond wäre jetzt der Planet,

01:13:20.140 --> 01:13:21.640
die Basisklasse vom Planeten wäre das Sonnensystem,

01:13:22.000 --> 01:13:24.000
die Basisklasse vom Sonnensystem wäre dann das Universum,

01:13:24.060 --> 01:13:26.120
die Basisklasse von dem Universum wäre dann vielleicht irgendwie,

01:13:26.220 --> 01:13:26.320
ne?

01:13:26.660 --> 01:13:26.900
Ja,

01:13:26.920 --> 01:13:28.620
genau solche Sachen will man eigentlich nicht machen,

01:13:28.840 --> 01:13:29.040
also,

01:13:29.140 --> 01:13:29.980
das ist genau das,

01:13:30.080 --> 01:13:30.600
was ich,

01:13:30.820 --> 01:13:31.320
äh,

01:13:31.780 --> 01:13:32.100
also,

01:13:32.640 --> 01:13:33.160
äh,

01:13:33.280 --> 01:13:33.920
das ist halt,

01:13:34.520 --> 01:13:34.720
ja,

01:13:34.840 --> 01:13:36.280
das klingt so ein bisschen danach,

01:13:36.380 --> 01:13:36.920
als würde das,

01:13:37.040 --> 01:13:38.260
aber ich würde das nicht versuchen,

01:13:38.360 --> 01:13:40.800
so auf die Alltagswelt so zu applizieren,

01:13:40.900 --> 01:13:41.840
sondern es geht tatsächlich darum,

01:13:41.920 --> 01:13:42.900
dass man Sachen programmieren kann,

01:13:42.940 --> 01:13:43.340
und das ist,

01:13:43.580 --> 01:13:43.820
ähm,

01:13:44.540 --> 01:13:45.280
das ist oft nicht so,

01:13:45.360 --> 01:13:45.500
wie,

01:13:45.720 --> 01:13:45.880
äh,

01:13:45.880 --> 01:13:46.680
das ist halt anders,

01:13:46.800 --> 01:13:47.300
das ist nicht so,

01:13:47.300 --> 01:13:48.420
wie die Welt da draußen,

01:13:48.600 --> 01:13:49.120
das ist schwer,

01:13:49.600 --> 01:13:49.820
oder so,

01:13:49.980 --> 01:13:50.360
man eigentlich,

01:13:50.520 --> 01:13:51.240
oft ist es nicht so,

01:13:51.280 --> 01:13:52.440
dass man die Welt da draußen modellieren muss,

01:13:52.500 --> 01:13:53.060
und dann das,

01:13:53.160 --> 01:13:53.860
was man modellieren muss,

01:13:53.900 --> 01:13:54.700
ist ganz anders,

01:13:54.820 --> 01:13:55.120
als das,

01:13:55.200 --> 01:13:56.180
was man so draußen normalerweise,

01:13:56.420 --> 01:13:57.420
man versucht diese Analogien,

01:13:57.500 --> 01:13:58.700
die gehen immer so ein bisschen ins,

01:14:00.020 --> 01:14:01.180
ich hab da Schwierigkeiten mit,

01:14:01.340 --> 01:14:01.480
äh,

01:14:01.540 --> 01:14:02.360
und ich finde,

01:14:02.500 --> 01:14:04.340
man kann sich das anders besser merken,

01:14:04.440 --> 01:14:04.860
wenn man jetzt,

01:14:05.040 --> 01:14:05.160
also,

01:14:05.340 --> 01:14:05.480
hier,

01:14:05.560 --> 01:14:06.000
ich würde sagen,

01:14:06.060 --> 01:14:08.340
vererben sollte man einfach eher nicht machen,

01:14:08.560 --> 01:14:09.200
lieber nicht machen,

01:14:09.780 --> 01:14:10.000
also,

01:14:10.120 --> 01:14:10.860
es gibt Fälle,

01:14:11.280 --> 01:14:11.720
wo das,

01:14:11.820 --> 01:14:12.100
äh,

01:14:12.540 --> 01:14:13.640
richtig und wichtig ist,

01:14:14.380 --> 01:14:14.760
aber,

01:14:15.220 --> 01:14:16.460
die sind selten,

01:14:17.300 --> 01:14:17.740
und,

01:14:17.860 --> 01:14:18.160
äh,

01:14:18.720 --> 01:14:19.580
was einem aber erklärt wird,

01:14:19.620 --> 01:14:19.700
ist,

01:14:19.760 --> 01:14:20.840
dass das der Normalfall,

01:14:20.880 --> 01:14:21.500
so macht man das halt,

01:14:21.760 --> 01:14:22.120
und dann würde ich sagen,

01:14:22.140 --> 01:14:22.660
das ist ganz falsch,

01:14:22.780 --> 01:14:22.980
nein,

01:14:23.400 --> 01:14:24.280
so macht man das eigentlich nicht,

01:14:24.580 --> 01:14:24.720
also,

01:14:24.820 --> 01:14:25.080
Vererbung,

01:14:25.160 --> 01:14:25.560
es gibt Fälle,

01:14:25.620 --> 01:14:26.040
wo das geht,

01:14:26.420 --> 01:14:27.080
wo das sinnvoll ist,

01:14:27.220 --> 01:14:27.500
aber,

01:14:27.660 --> 01:14:28.100
das ist nicht so,

01:14:28.140 --> 01:14:28.800
dass man das immer machen,

01:14:28.940 --> 01:14:29.080
so,

01:14:29.220 --> 01:14:30.660
oder normalerweise so machen sollte,

01:14:31.000 --> 01:14:32.100
sondern das ist halt eher die Ausnahme,

01:14:32.880 --> 01:14:33.720
normalerweise sollte man,

01:14:33.780 --> 01:14:34.420
wenn man zum Beispiel Code,

01:14:34.500 --> 01:14:35.700
in zwei Klassen wiederverwenden will,

01:14:35.800 --> 01:14:36.700
dann macht man halt Mixin,

01:14:37.840 --> 01:14:39.000
und nicht diese Vererbung,

01:14:39.900 --> 01:14:40.180
weil,

01:14:40.480 --> 01:14:41.060
das ist halt,

01:14:41.400 --> 01:14:42.120
das ist auch am Anfang,

01:14:42.180 --> 01:14:42.480
das geht,

01:14:42.620 --> 01:14:43.220
geht ganz gut,

01:14:43.220 --> 01:14:44.540
und sobald es komplizierter wird,

01:14:44.720 --> 01:14:45.880
hat man da große Probleme,

01:14:46.020 --> 01:14:46.480
weil du dann,

01:14:47.200 --> 01:14:47.620
deine,

01:14:47.620 --> 01:14:48.240
deine Hierarchie,

01:14:48.260 --> 01:14:49.200
die muss halt einfach stimmen,

01:14:49.280 --> 01:14:50.400
die muss halt passen auf dein Problem,

01:14:50.500 --> 01:14:51.720
das kannst du hinterher nicht mehr gut,

01:14:51.740 --> 01:14:52.000
äh,

01:14:52.000 --> 01:14:52.300
ändern,

01:14:52.560 --> 01:14:53.840
und hinterher gut anpassen,

01:14:53.900 --> 01:14:55.120
das geht alles nicht so richtig schön,

01:14:55.500 --> 01:14:56.500
und am Anfang zu sehen,

01:14:56.920 --> 01:14:57.700
wie das richtig wäre,

01:14:57.760 --> 01:14:58.240
für das Problem,

01:14:58.300 --> 01:14:59.040
was man eigentlich lösen will,

01:14:59.060 --> 01:15:00.020
ist sehr schwer.

01:15:00.160 --> 01:15:00.260
Ja,

01:15:00.280 --> 01:15:01.520
weil man das Problem meistens gar nicht genau kennt.

01:15:01.520 --> 01:15:01.780
Genau,

01:15:01.860 --> 01:15:03.080
man kennt meistens das Problem nicht richtig,

01:15:03.560 --> 01:15:05.240
und bei Mixins ist es relativ simpel,

01:15:05.320 --> 01:15:06.040
das ist halt so wie,

01:15:06.460 --> 01:15:06.800
keine Ahnung,

01:15:06.860 --> 01:15:07.280
wenn ich nur,

01:15:07.560 --> 01:15:09.260
wenn ich ohne Objektorientierung,

01:15:09.400 --> 01:15:09.620
äh,

01:15:09.620 --> 01:15:10.020
programmiere,

01:15:10.020 --> 01:15:11.940
dann habe ich halt Funktionen,

01:15:11.940 --> 01:15:12.740
die ich aufrufe,

01:15:13.120 --> 01:15:13.540
und,

01:15:13.580 --> 01:15:13.760
äh,

01:15:13.780 --> 01:15:14.500
wenn ich jetzt merke,

01:15:14.600 --> 01:15:16.340
ich benutze den gleichen Code an drei,

01:15:16.400 --> 01:15:17.360
vier unterschiedlichen Stellen,

01:15:17.840 --> 01:15:18.000
ja,

01:15:18.440 --> 01:15:18.920
dann,

01:15:19.100 --> 01:15:19.360
äh,

01:15:19.860 --> 01:15:21.040
mache ich halt eine Funktion drauf,

01:15:21.140 --> 01:15:21.400
äh,

01:15:21.480 --> 01:15:22.600
oder draußen rufe den an den Stellen,

01:15:22.700 --> 01:15:23.080
wo ich,

01:15:23.200 --> 01:15:23.480
äh,

01:15:23.480 --> 01:15:24.340
sozusagen den,

01:15:24.480 --> 01:15:25.300
das verwenden möchte,

01:15:25.420 --> 01:15:26.480
den Code einfach auf,

01:15:27.180 --> 01:15:27.460
anstelle,

01:15:27.600 --> 01:15:28.480
dass ich den Code aber entstehen habe.

01:15:28.960 --> 01:15:30.980
Und genauso kann man das mit Klassen im Grunde auch machen,

01:15:31.180 --> 01:15:31.520
und,

01:15:31.560 --> 01:15:31.760
äh,

01:15:31.820 --> 01:15:32.040
Code,

01:15:32.080 --> 01:15:33.240
den ich in mehreren Klassen benutze,

01:15:33.280 --> 01:15:34.340
den ziehe ich halt in Mixins raus.

01:15:35.220 --> 01:15:36.980
Und dann ist es relativ easy,

01:15:37.100 --> 01:15:37.320
weil,

01:15:37.580 --> 01:15:37.880
äh,

01:15:38.120 --> 01:15:38.300
ja,

01:15:39.300 --> 01:15:39.620
äh,

01:15:39.620 --> 01:15:39.820
die,

01:15:40.020 --> 01:15:41.600
diese Mixins machen halt nichts anderes,

01:15:41.800 --> 01:15:41.980
außer,

01:15:42.180 --> 01:15:42.380
äh,

01:15:42.440 --> 01:15:43.880
irgendwie halt eine Methode sozusagen zu,

01:15:44.000 --> 01:15:45.060
hinzuzufügen zu einer Klasse.

01:15:46.020 --> 01:15:46.380
Und,

01:15:46.460 --> 01:15:46.920
ähm,

01:15:47.420 --> 01:15:47.600
ja,

01:15:48.620 --> 01:15:49.040
ähm,

01:15:50.120 --> 01:15:51.140
während so Vererbungen,

01:15:51.380 --> 01:15:51.720
hm,

01:15:52.100 --> 01:15:53.020
ja,

01:15:53.380 --> 01:15:54.220
also es macht halt mehr.

01:15:55.040 --> 01:15:55.720
Das tut mehr,

01:15:55.800 --> 01:15:56.040
also was soll,

01:15:56.060 --> 01:15:57.620
also es gibt halt dann diese Basis,

01:15:57.700 --> 01:15:57.780
ne,

01:15:57.840 --> 01:15:58.300
Basisklassen,

01:15:58.400 --> 01:15:59.120
Basis oder sowas,

01:15:59.200 --> 01:16:00.160
oder es gibt noch sowas wie,

01:16:00.220 --> 01:16:00.520
ähm,

01:16:00.680 --> 01:16:01.960
Message Resolution Order,

01:16:02.060 --> 01:16:02.560
MROs,

01:16:02.600 --> 01:16:03.220
wo man dann gucken kann,

01:16:03.620 --> 01:16:05.380
welche Methode in welcher Reihenfolge aufrufen werden,

01:16:05.440 --> 01:16:06.820
weil die sich ja gegenseitig überschreiben können.

01:16:07.180 --> 01:16:07.540
Und,

01:16:07.540 --> 01:16:07.780
ähm,

01:16:07.920 --> 01:16:08.340
das Problem,

01:16:08.440 --> 01:16:09.140
was man dann hat irgendwann ist,

01:16:09.140 --> 01:16:09.780
ist, dass wenn man da,

01:16:10.100 --> 01:16:10.480
wie du sagst,

01:16:10.520 --> 01:16:11.000
einen Fehler macht,

01:16:11.080 --> 01:16:14.220
dann hat man Zirkelvererbung oder sowas.

01:16:14.780 --> 01:16:15.060
Und das sollte man wahrscheinlich nicht verwehren.

01:16:15.060 --> 01:16:15.140
Ja,

01:16:15.220 --> 01:16:15.960
das passieren halt,

01:16:16.220 --> 01:16:16.240
äh,

01:16:16.240 --> 01:16:16.400
genau,

01:16:16.500 --> 01:16:17.680
wenn man irgendwas falsch macht,

01:16:17.780 --> 01:16:19.320
dann passieren unerwartete Dinge,

01:16:19.520 --> 01:16:20.200
die man auch nicht so,

01:16:20.280 --> 01:16:21.360
die nicht so offensichtlich sind.

01:16:21.600 --> 01:16:21.820
Und,

01:16:22.480 --> 01:16:22.980
äh,

01:16:23.140 --> 01:16:23.300
ja,

01:16:23.380 --> 01:16:24.920
und es kann auch sehr schnell sehr hässlich werden.

01:16:25.060 --> 01:16:25.240
Also,

01:16:25.480 --> 01:16:25.940
ähm,

01:16:26.440 --> 01:16:27.300
es gibt wenig Fälle,

01:16:27.360 --> 01:16:29.160
wo das eine super sinnvolle Geschichte ist.

01:16:29.220 --> 01:16:29.560
Das ist aber so,

01:16:29.640 --> 01:16:30.620
es ist halt so ein bisschen auch wieder,

01:16:30.800 --> 01:16:31.760
wie bei den Dekoratoren,

01:16:31.760 --> 01:16:33.840
auch wenn man das am Anfang mal verstanden hat,

01:16:33.900 --> 01:16:34.580
wie das funktioniert,

01:16:34.760 --> 01:16:35.020
also ich meine,

01:16:35.020 --> 01:16:37.040
auch wenn man das mit der Vererbung verstanden hat,

01:16:37.060 --> 01:16:37.620
wie das funktioniert,

01:16:38.460 --> 01:16:38.920
dann ist das,

01:16:39.100 --> 01:16:40.120
dann fühlt sich das so toll an,

01:16:40.160 --> 01:16:40.600
dass man da,

01:16:40.700 --> 01:16:40.900
äh,

01:16:40.940 --> 01:16:42.060
ganz viele Dekoratoren machen will,

01:16:42.140 --> 01:16:43.060
ganz viele Vererbungen

01:16:43.060 --> 01:16:44.600
und am besten das Ganze irgendwie

01:16:44.600 --> 01:16:46.740
in verschachtelte List-Comprehensions-Fakt oder so.

01:16:46.960 --> 01:16:48.260
Und mit abstrakten Metaklassen bitte?

01:16:48.580 --> 01:16:48.880
Ja,

01:16:48.920 --> 01:16:49.340
Metaklassen,

01:16:49.460 --> 01:16:49.720
oh ja,

01:16:49.940 --> 01:16:50.400
mhm,

01:16:50.520 --> 01:16:50.720
äh,

01:16:52.120 --> 01:16:52.360
aber,

01:16:52.700 --> 01:16:53.180
äh,

01:16:53.380 --> 01:16:53.920
ich weiß nicht,

01:16:54.140 --> 01:16:54.920
vielleicht keine gute Idee.

01:16:55.100 --> 01:16:55.880
Also jedenfalls nicht am Anfang.

01:16:56.060 --> 01:16:56.240
Also,

01:16:56.540 --> 01:16:56.960
ähm,

01:16:57.500 --> 01:16:57.740
wenn man,

01:16:57.800 --> 01:16:59.180
wenn man dann irgendwann genau weiß,

01:16:59.180 --> 01:17:00.300
welches Problem man lösen möchte

01:17:00.300 --> 01:17:01.880
und man möchte halt ein Framework bauen,

01:17:02.100 --> 01:17:02.480
das halt,

01:17:02.820 --> 01:17:03.200
wo man dann,

01:17:03.200 --> 01:17:04.980
also nehmen wir irgendwie sowas wie General Rest Framework,

01:17:05.040 --> 01:17:06.020
finde ich das relativ gelungen.

01:17:06.740 --> 01:17:07.020
Äh,

01:17:07.140 --> 01:17:07.400
da,

01:17:07.560 --> 01:17:07.900
äh,

01:17:08.000 --> 01:17:09.520
kann man oft viel Funktionalität,

01:17:09.620 --> 01:17:09.880
äh,

01:17:10.160 --> 01:17:10.540
abbilden,

01:17:10.580 --> 01:17:10.760
dadurch,

01:17:10.840 --> 01:17:12.380
dass man jetzt sozusagen von irgendeiner,

01:17:12.580 --> 01:17:14.460
von irgendeinem Viewset oder so erbt

01:17:14.460 --> 01:17:15.940
und dann überschreiten wir noch zwei,

01:17:16.020 --> 01:17:16.480
drei Methoden,

01:17:16.580 --> 01:17:17.360
passt ein bisschen was an

01:17:17.360 --> 01:17:18.240
und dann macht das ganz viel.

01:17:19.080 --> 01:17:19.620
Sehr schön,

01:17:19.720 --> 01:17:20.400
aber dafür muss man sehr,

01:17:20.520 --> 01:17:21.420
sehr genau verstanden haben,

01:17:21.500 --> 01:17:22.380
welches Problem man hat

01:17:22.380 --> 01:17:22.820
und,

01:17:23.000 --> 01:17:23.400
ähm,

01:17:24.440 --> 01:17:25.660
wenn man so anfängt,

01:17:25.760 --> 01:17:26.060
dann,

01:17:26.060 --> 01:17:26.160
äh,

01:17:26.780 --> 01:17:28.240
üblicherweise landet man relativ,

01:17:28.420 --> 01:17:28.700
äh,

01:17:29.360 --> 01:17:30.980
schnell in einem ziemlich üblen Zustand.

01:17:31.060 --> 01:17:31.640
In Teufelsküche,

01:17:31.700 --> 01:17:32.360
in der Schlangengrube.

01:17:33.200 --> 01:17:33.520
Ja,

01:17:33.520 --> 01:17:34.740
ja,

01:17:34.900 --> 01:17:36.020
man kann das ja immer noch machen am Schluss,

01:17:36.120 --> 01:17:37.220
wenn man dann irgendwie wirklich verstanden hat,

01:17:37.240 --> 01:17:37.880
was man tut und so,

01:17:38.020 --> 01:17:39.400
dann kann man ja immer noch dann irgendwie

01:17:39.400 --> 01:17:40.360
Klassengerecht hinbauen und so,

01:17:40.420 --> 01:17:41.300
aber am Anfang,

01:17:41.440 --> 01:17:41.640
äh,

01:17:41.900 --> 01:17:42.460
lieber nicht.

01:17:42.520 --> 01:17:42.780
Ich glaube,

01:17:42.860 --> 01:17:44.280
das ist jetzt der richtige Ort für die nächste Frage,

01:17:44.560 --> 01:17:44.580
ähm,

01:17:44.700 --> 01:17:45.060
die wäre,

01:17:45.140 --> 01:17:46.040
was ist ein Monkey Patch?

01:17:47.780 --> 01:17:48.100
Äh,

01:17:48.200 --> 01:17:48.340
ja,

01:17:48.480 --> 01:17:48.840
das ist,

01:17:49.060 --> 01:17:50.780
da das alles Objekte sind in Python,

01:17:51.040 --> 01:17:51.340
ähm,

01:17:51.400 --> 01:17:52.160
kann man die natürlich,

01:17:52.260 --> 01:17:54.540
und die alle dynamisch,

01:17:54.640 --> 01:17:54.960
äh,

01:17:55.060 --> 01:17:55.780
änderbar sind,

01:17:55.900 --> 01:17:56.080
äh,

01:17:56.080 --> 01:17:56.760
kann man ja auch,

01:17:56.860 --> 01:17:57.100
äh,

01:17:57.100 --> 01:17:58.120
sozusagen einfach die Methode,

01:17:58.820 --> 01:17:59.060
äh,

01:17:59.120 --> 01:17:59.460
einer,

01:17:59.700 --> 01:18:00.900
eines Objektes einfach,

01:18:01.220 --> 01:18:01.620
man kann ja sagen,

01:18:01.620 --> 01:18:01.880
zum Beispiel,

01:18:01.940 --> 01:18:02.260
wenn ich da,

01:18:02.660 --> 01:18:03.540
äh,

01:18:03.560 --> 01:18:04.740
nicht nur Attribute setzen,

01:18:04.800 --> 01:18:06.060
sondern ich kann auch die Methode einfach überschreiben.

01:18:06.300 --> 01:18:07.080
Ich könnte zum Beispiel sagen,

01:18:07.140 --> 01:18:08.340
wenn ich meinen Barbaren habe,

01:18:08.420 --> 01:18:08.500
ne,

01:18:08.500 --> 01:18:09.300
von dem wir eben geredet haben,

01:18:09.440 --> 01:18:10.000
und er hat,

01:18:10.120 --> 01:18:10.300
äh,

01:18:10.340 --> 01:18:10.920
einen Attribut,

01:18:10.980 --> 01:18:11.580
das heißt Attacke,

01:18:11.700 --> 01:18:12.740
und da ist immer irgendwas drauf,

01:18:13.500 --> 01:18:14.620
dann kann ich einfach die überschreiben,

01:18:14.720 --> 01:18:15.760
und dann macht er bei der Attacke irgendwas anderes,

01:18:15.840 --> 01:18:16.480
zum Beispiel heilte ich,

01:18:16.560 --> 01:18:16.740
oder so.

01:18:16.760 --> 01:18:16.920
Genau,

01:18:17.020 --> 01:18:17.200
genau,

01:18:17.360 --> 01:18:18.320
und ich könnte einfach sagen,

01:18:18.540 --> 01:18:18.800
äh,

01:18:19.220 --> 01:18:19.440
ja,

01:18:19.600 --> 01:18:20.220
äh,

01:18:20.660 --> 01:18:20.920
äh,

01:18:21.020 --> 01:18:23.380
barbar.attack gleich Lambda X,

01:18:23.560 --> 01:18:23.980
äh,

01:18:24.040 --> 01:18:24.420
YZ,

01:18:24.420 --> 01:18:25.720
was auch immer da übergeben wird.

01:18:26.060 --> 01:18:28.420
Das wäre zum Beispiel wahrscheinlich die Möglichkeit,

01:18:28.420 --> 01:18:28.940
wie man,

01:18:28.980 --> 01:18:29.680
ähm,

01:18:29.800 --> 01:18:31.400
Vererbung bei Klassen richtig macht,

01:18:31.480 --> 01:18:32.460
indem man die Basisklasse hat,

01:18:32.540 --> 01:18:33.020
die wäre jetzt,

01:18:33.140 --> 01:18:33.340
ähm,

01:18:33.960 --> 01:18:35.720
wahrscheinlich in so einem Rollenspiel,

01:18:36.120 --> 01:18:36.880
sowas wie eine Person,

01:18:37.300 --> 01:18:38.920
und dann vererbt man dann auch verschiedene,

01:18:39.480 --> 01:18:39.760
äh,

01:18:39.840 --> 01:18:40.280
weiß ich nicht,

01:18:40.440 --> 01:18:40.780
äh,

01:18:40.780 --> 01:18:41.020
Rassen,

01:18:41.100 --> 01:18:41.700
zum Beispiel Echse,

01:18:41.800 --> 01:18:42.300
oder Mensch,

01:18:42.360 --> 01:18:42.820
oder sowas.

01:18:43.100 --> 01:18:43.500
Na,

01:18:43.920 --> 01:18:44.200
ne,

01:18:44.380 --> 01:18:45.140
ich bin da sehr vorsichtig.

01:18:45.140 --> 01:18:46.200
Und dann hat man dann Klassen,

01:18:46.420 --> 01:18:47.240
die man dazu macht,

01:18:47.340 --> 01:18:48.260
also zum Beispiel Magier,

01:18:48.320 --> 01:18:48.980
oder Barbar,

01:18:49.620 --> 01:18:51.160
und dann kann man zum Beispiel Attacke,

01:18:51.340 --> 01:18:51.840
oder,

01:18:52.160 --> 01:18:52.360
äh,

01:18:52.360 --> 01:18:52.660
überschreiben.

01:18:52.660 --> 01:18:53.220
Überschreibt man dann.

01:18:53.500 --> 01:18:53.620
Ja.

01:18:53.620 --> 01:18:53.800
Ja,

01:18:53.900 --> 01:18:55.540
aber das ist halt sehr verführerisch,

01:18:55.540 --> 01:18:56.620
dass man halt ein Bild davon hat,

01:18:56.820 --> 01:18:57.080
wie das,

01:18:57.260 --> 01:18:57.500
äh,

01:18:57.600 --> 01:18:57.740
wie,

01:18:57.840 --> 01:18:58.780
wie sozusagen die Welt,

01:18:58.880 --> 01:19:00.300
die man im Spiel bauen will,

01:19:00.800 --> 01:19:00.940
äh,

01:19:00.960 --> 01:19:01.580
aufgebaut ist,

01:19:01.680 --> 01:19:03.880
aber tatsächlich ist das zu programmieren oft was anderes,

01:19:04.060 --> 01:19:05.460
als nur diese Welt zu modellieren,

01:19:05.560 --> 01:19:05.940
und dann,

01:19:06.240 --> 01:19:07.300
das ist nicht das,

01:19:07.420 --> 01:19:08.000
oder jedenfalls,

01:19:08.060 --> 01:19:08.620
meine Erfahrung ist so,

01:19:08.680 --> 01:19:08.820
dass,

01:19:09.040 --> 01:19:10.800
wenn man das so versucht zu modellieren,

01:19:10.880 --> 01:19:11.740
wie man sich das vorstellt,

01:19:11.880 --> 01:19:12.100
dann,

01:19:12.180 --> 01:19:12.400
äh,

01:19:12.400 --> 01:19:13.620
passt es nicht so gut auf das,

01:19:13.680 --> 01:19:14.420
wie man das programmieren will.

01:19:15.380 --> 01:19:15.700
Sondern,

01:19:15.900 --> 01:19:16.600
es ist halt einfach,

01:19:16.940 --> 01:19:17.100
ja,

01:19:17.180 --> 01:19:17.520
es ist,

01:19:17.680 --> 01:19:17.880
äh,

01:19:17.960 --> 01:19:18.180
ist.

01:19:18.820 --> 01:19:19.480
Aber das zu verstehen,

01:19:19.480 --> 01:19:19.700
das ist,

01:19:19.700 --> 01:19:21.160
das ist vielleicht schwierig,

01:19:21.320 --> 01:19:21.860
also für jemanden,

01:19:21.920 --> 01:19:22.580
der das nicht weiß,

01:19:22.680 --> 01:19:22.840
warum,

01:19:22.840 --> 01:19:23.100
wieso,

01:19:23.500 --> 01:19:24.540
warum man das dann einfach nicht macht,

01:19:24.620 --> 01:19:25.600
obwohl das ja so intuitiv,

01:19:25.660 --> 01:19:26.780
endlich ja so einen Zugang dazu gibt.

01:19:26.780 --> 01:19:27.020
Ja,

01:19:27.160 --> 01:19:27.360
genau,

01:19:27.500 --> 01:19:27.800
also ich,

01:19:28.080 --> 01:19:28.100
ich,

01:19:28.100 --> 01:19:28.520
das ist,

01:19:28.580 --> 01:19:29.340
das ist halt,

01:19:29.500 --> 01:19:29.540
wie,

01:19:29.660 --> 01:19:29.780
wie,

01:19:30.120 --> 01:19:31.140
es gibt da auch immer diesen Spruch,

01:19:31.220 --> 01:19:31.300
ne,

01:19:31.340 --> 01:19:32.600
es gibt für jedes Problem eine Lösung,

01:19:32.700 --> 01:19:32.960
die ist,

01:19:33.020 --> 01:19:34.000
äh,

01:19:34.120 --> 01:19:34.460
einfach,

01:19:34.780 --> 01:19:35.580
leicht zu verstehen,

01:19:35.980 --> 01:19:36.300
äh,

01:19:36.420 --> 01:19:37.280
elegant und falsch.

01:19:38.580 --> 01:19:40.200
Das ist halt auch immer,

01:19:40.300 --> 01:19:40.540
und ich,

01:19:40.780 --> 01:19:41.960
was mich ärgert so ein bisschen,

01:19:41.960 --> 01:19:42.120
ist,

01:19:42.200 --> 01:19:43.420
dass es halt auch immer so Programmier-,

01:19:43.420 --> 01:19:45.160
Lehrbüchern oder so oft so,

01:19:45.720 --> 01:19:46.680
oder schlimm ist es,

01:19:47.240 --> 01:19:47.160
äh,

01:19:47.260 --> 01:19:47.440
ja,

01:19:47.480 --> 01:19:48.420
wenn Leute programmieren,

01:19:48.780 --> 01:19:49.160
äh,

01:19:49.200 --> 01:19:49.600
erklären,

01:19:49.960 --> 01:19:51.340
dann vielleicht gar nicht selber so,

01:19:51.340 --> 01:19:51.680
äh,

01:19:51.760 --> 01:19:52.320
da drin stecken,

01:19:52.660 --> 01:19:53.560
dann machen die das oft so,

01:19:53.620 --> 01:19:54.360
dann fangen die da an,

01:19:54.380 --> 01:19:56.540
mit irgendwelchen Analogien aus dem täglichen Leben zu kommen,

01:19:56.680 --> 01:19:57.600
und dass man halt so,

01:19:57.760 --> 01:19:58.800
das abbildet,

01:19:58.860 --> 01:19:59.560
das ist aber,

01:20:00.320 --> 01:20:01.040
ich weiß nicht,

01:20:01.120 --> 01:20:01.260
ich,

01:20:01.760 --> 01:20:01.940
das,

01:20:02.200 --> 01:20:03.180
da liegt kein Segen drauf,

01:20:03.800 --> 01:20:04.020
das,

01:20:04.200 --> 01:20:05.480
das funktioniert so nicht,

01:20:06.120 --> 01:20:06.540
ähm,

01:20:06.920 --> 01:20:07.200
äh,

01:20:07.400 --> 01:20:07.580
ja.

01:20:09.100 --> 01:20:09.460
Naja.

01:20:09.460 --> 01:20:09.520
Ja.

01:20:10.020 --> 01:20:10.380
Also,

01:20:10.480 --> 01:20:10.980
ihr seht schon,

01:20:11.040 --> 01:20:12.420
wenn ihr über die Schlangengrube drüber wollt,

01:20:12.500 --> 01:20:13.680
dann ist da manchmal so ein bisschen,

01:20:14.520 --> 01:20:14.760
ja,

01:20:15.440 --> 01:20:16.660
Indiana Jones-Seit hängt von der Decke,

01:20:16.780 --> 01:20:17.180
rüber schwingen,

01:20:17.240 --> 01:20:17.520
juhu.

01:20:17.640 --> 01:20:17.780
Ich,

01:20:17.780 --> 01:20:18.080
ich würde,

01:20:18.240 --> 01:20:18.280
ich,

01:20:18.520 --> 01:20:18.640
so,

01:20:18.700 --> 01:20:20.800
also so Ratschlag wäre halt eher,

01:20:20.800 --> 01:20:21.300
ist versuchen,

01:20:21.420 --> 01:20:22.020
einfach zu halten,

01:20:22.120 --> 01:20:23.160
nicht so komplizierte Sachen,

01:20:23.260 --> 01:20:24.380
ganz komplizierten Sprachwitscher,

01:20:24.460 --> 01:20:25.640
vielleicht nicht so viel zu verwenden,

01:20:26.260 --> 01:20:26.440
äh,

01:20:26.480 --> 01:20:26.640
oder,

01:20:26.760 --> 01:20:27.160
äh,

01:20:27.160 --> 01:20:28.560
das ein bisschen hinaus zu zögern,

01:20:29.320 --> 01:20:29.540
ja,

01:20:29.660 --> 01:20:30.280
ich verstehe natürlich,

01:20:30.360 --> 01:20:31.860
dass das immer so ein bisschen auch reizvoll ist,

01:20:31.980 --> 01:20:32.140
äh,

01:20:32.180 --> 01:20:32.380
aber,

01:20:32.860 --> 01:20:32.980
ja,

01:20:32.980 --> 01:20:33.020
ja,

01:20:33.020 --> 01:20:33.260
und nicht,

01:20:33.320 --> 01:20:34.140
nicht irgendwie so,

01:20:34.240 --> 01:20:34.400
wenn,

01:20:34.480 --> 01:20:35.100
wenn so Dinge,

01:20:35.240 --> 01:20:35.840
die so aussehen,

01:20:35.940 --> 01:20:36.660
als wie die Weltformel,

01:20:36.720 --> 01:20:37.180
die alles löst,

01:20:37.280 --> 01:20:37.780
mhm,

01:20:37.800 --> 01:20:38.100
mhm,

01:20:39.160 --> 01:20:40.560
das ist ja skeptisch sein.

01:20:42.500 --> 01:20:42.860
Ja,

01:20:42.900 --> 01:20:44.220
dann machen wir direkt wieder mit einfachen Dingen weiter,

01:20:44.380 --> 01:20:44.580
ähm,

01:20:45.800 --> 01:20:46.280
was ist denn,

01:20:46.480 --> 01:20:46.740
ähm,

01:20:47.120 --> 01:20:48.120
was sind denn Argumente,

01:20:48.120 --> 01:20:49.040
oder Keyword-Argumente,

01:20:49.120 --> 01:20:50.240
was sind Args und Quarks?

01:20:51.100 --> 01:20:51.400
Ah,

01:20:51.520 --> 01:20:51.620
ja,

01:20:51.700 --> 01:20:51.820
ja,

01:20:51.840 --> 01:20:52.040
ja,

01:20:52.040 --> 01:20:52.200
ja,

01:20:52.200 --> 01:20:52.720
das ist auch etwas,

01:20:52.780 --> 01:20:54.140
was immer ein bisschen verwirrend ist,

01:20:54.280 --> 01:20:54.560
äh,

01:20:54.980 --> 01:20:55.180
ja,

01:20:55.380 --> 01:20:56.080
also Funktionen,

01:20:56.140 --> 01:20:56.580
Methoden,

01:20:56.660 --> 01:20:57.300
äh,

01:20:57.320 --> 01:20:57.580
haben,

01:20:57.680 --> 01:20:58.460
haben Argumente,

01:20:58.700 --> 01:20:59.200
das heißt Dinge,

01:20:59.240 --> 01:21:01.080
die man übergeben kann,

01:21:01.400 --> 01:21:01.720
äh,

01:21:01.920 --> 01:21:02.520
mhm,

01:21:03.160 --> 01:21:03.440
äh,

01:21:03.940 --> 01:21:06.660
ganz normale Positionsargumente sind halt sozusagen das,

01:21:06.820 --> 01:21:07.140
äh,

01:21:07.540 --> 01:21:08.960
das Übliche irgendwie,

01:21:09.120 --> 01:21:09.860
die haben halt einen fest,

01:21:10.200 --> 01:21:11.320
die sind an einer festen Stelle,

01:21:11.500 --> 01:21:13.220
und werden dadurch dann identifiziert,

01:21:13.300 --> 01:21:14.460
dass sie halt an der ersten,

01:21:14.540 --> 01:21:14.680
zweiten,

01:21:14.680 --> 01:21:15.640
dritten Stelle oder so stehen,

01:21:16.860 --> 01:21:18.100
und dann gibt es halt noch Keyword-Argumente,

01:21:18.120 --> 01:21:18.520
die,

01:21:19.160 --> 01:21:19.460
äh,

01:21:19.860 --> 01:21:21.740
wo man dann explizit dazu sagt,

01:21:21.920 --> 01:21:22.100
äh,

01:21:22.320 --> 01:21:22.800
welches,

01:21:23.000 --> 01:21:23.240
ähm,

01:21:24.100 --> 01:21:25.540
welches Argument man denn jetzt gemeint hat,

01:21:26.220 --> 01:21:26.460
sozusagen,

01:21:26.500 --> 01:21:27.960
das schreibt man dann halt sowohl in die,

01:21:28.040 --> 01:21:28.120
äh,

01:21:29.140 --> 01:21:30.700
Funktionsdefinitionen rein,

01:21:30.880 --> 01:21:31.620
als auch dann,

01:21:31.780 --> 01:21:32.020
äh,

01:21:32.080 --> 01:21:32.660
wenn man es übergibt,

01:21:32.760 --> 01:21:34.760
wobei man es beim Übergeben nicht unbedingt braucht,

01:21:35.060 --> 01:21:35.280
also,

01:21:35.660 --> 01:21:36.300
da ist es dann halt so,

01:21:36.320 --> 01:21:37.040
wenn man das weglässt,

01:21:37.120 --> 01:21:39.780
dann wird halt das nächste Keyword-Argument genommen,

01:21:40.840 --> 01:21:41.560
das ist so ein bisschen,

01:21:42.000 --> 01:21:42.400
mhm,

01:21:43.060 --> 01:21:44.700
da können dann komische Sachen passieren,

01:21:45.240 --> 01:21:46.420
und dann ist es auch so,

01:21:46.460 --> 01:21:46.840
dass man,

01:21:47.020 --> 01:21:47.240
äh,

01:21:47.240 --> 01:21:47.820
wenn man sich,

01:21:48.000 --> 01:21:48.100
äh,

01:21:48.120 --> 01:21:49.960
wenn man jetzt eine Liste von Argumenten übergibt,

01:21:50.220 --> 01:21:50.560
äh,

01:21:50.640 --> 01:21:51.000
ähm,

01:21:51.760 --> 01:21:53.820
dann kann man die natürlich alle einzeln übergeben,

01:21:53.960 --> 01:21:55.940
man kann die aber auch insgesamt übergeben.

01:21:56.060 --> 01:21:56.920
Mit Stähnchen dann,

01:21:57.080 --> 01:21:58.420
oder mit Stähnchen,

01:21:58.520 --> 01:21:58.920
Stähnchen,

01:21:59.020 --> 01:22:01.000
also wenn man die Liste hat in der Hand,

01:22:01.240 --> 01:22:01.640
äh,

01:22:01.740 --> 01:22:02.680
wenn man eine Liste hat oder Tupel,

01:22:02.760 --> 01:22:04.900
dann kann man einfach einen Stern davor schreiben,

01:22:05.520 --> 01:22:07.760
und dann wird das automatisch sozusagen als,

01:22:08.000 --> 01:22:08.120
äh,

01:22:08.900 --> 01:22:09.060
ja,

01:22:10.440 --> 01:22:11.540
Argumente dann übergeben,

01:22:11.680 --> 01:22:12.020
das heißt,

01:22:12.120 --> 01:22:14.480
man sagt dann irgendwie,

01:22:14.600 --> 01:22:15.120
äh,

01:22:16.000 --> 01:22:16.120
Funktion,

01:22:16.980 --> 01:22:17.560
Klammer auf,

01:22:17.560 --> 01:22:18.160
Stern,

01:22:18.500 --> 01:22:19.460
und dann eben,

01:22:20.920 --> 01:22:21.240
Args,

01:22:21.340 --> 01:22:21.720
Argumente,

01:22:21.860 --> 01:22:22.420
oder wie auch immer das,

01:22:22.540 --> 01:22:22.640
die,

01:22:22.660 --> 01:22:23.220
die Items,

01:22:23.440 --> 01:22:24.420
diese Struktur heißt,

01:22:24.500 --> 01:22:25.380
die man jetzt gerade in der Hand hat,

01:22:25.760 --> 01:22:26.200
Klammer zu,

01:22:26.320 --> 01:22:26.680
und dann,

01:22:26.880 --> 01:22:27.060
äh,

01:22:27.060 --> 01:22:28.840
kann man in der Funktionsdefinition drinstehen haben,

01:22:28.920 --> 01:22:29.140
sowas,

01:22:29.660 --> 01:22:30.440
Def-Funktion,

01:22:30.700 --> 01:22:31.400
Klammer auf,

01:22:31.540 --> 01:22:31.720
A,

01:22:31.800 --> 01:22:32.020
Komma B,

01:22:32.120 --> 01:22:32.540
Komma C,

01:22:32.760 --> 01:22:33.120
und,

01:22:33.240 --> 01:22:33.500
äh,

01:22:33.980 --> 01:22:34.120
ja,

01:22:34.220 --> 01:22:36.160
muss dann natürlich alles irgendwie stimmen von der Anzahl und so,

01:22:36.280 --> 01:22:36.900
aber, äh,

01:22:36.900 --> 01:22:38.020
das passiert dann automatisch.

01:22:38.040 --> 01:22:39.660
Ich finde das bei Keyword-Argumenten relativ witzig,

01:22:39.720 --> 01:22:40.640
weil da kann man alle viele Sachen,

01:22:40.700 --> 01:22:41.800
die man irgendwie zugewiesen hat,

01:22:42.160 --> 01:22:42.300
Ja.

01:22:42.580 --> 01:22:43.680
irgendwie in eine Liste packen,

01:22:47.560 --> 01:22:48.240
genau,

01:22:48.320 --> 01:22:48.440
das,

01:22:49.080 --> 01:22:49.400
eben,

01:22:49.660 --> 01:22:52.080
bei normalen Positionsargumenten ist es halt,

01:22:52.200 --> 01:22:52.520
äh,

01:22:52.820 --> 01:22:54.740
entweder man übergibt sie per Position,

01:22:54.860 --> 01:22:55.360
oder Stern,

01:22:55.560 --> 01:22:55.860
äh,

01:22:56.360 --> 01:22:58.600
kann auch eben in der Funktionsdefinition sagen,

01:22:58.700 --> 01:22:58.780
so,

01:22:58.860 --> 01:23:00.120
das können jetzt hier beliebig viele sein,

01:23:00.180 --> 01:23:01.020
dann schreibt man halt nicht A,

01:23:01.100 --> 01:23:01.320
Komma B,

01:23:01.400 --> 01:23:01.860
Komma C rein,

01:23:01.920 --> 01:23:02.980
sondern Stern,

01:23:03.100 --> 01:23:03.520
Args,

01:23:04.300 --> 01:23:04.720
Komma,

01:23:05.000 --> 01:23:05.380
und dann,

01:23:05.380 --> 01:23:08.520
da kommen dann halt beliebig viele Argumente rein,

01:23:08.600 --> 01:23:10.120
die dann hinterher in der Liste Args sind,

01:23:10.260 --> 01:23:10.700
wenn man,

01:23:11.140 --> 01:23:12.720
vielleicht kennen Leute das noch von Perl oder so,

01:23:12.760 --> 01:23:13.360
gibt das nur so,

01:23:14.260 --> 01:23:14.440
äh,

01:23:14.640 --> 01:23:15.480
das geht in Python auch,

01:23:16.360 --> 01:23:17.420
ist da aber ein Spezialfall,

01:23:18.040 --> 01:23:18.420
ähm,

01:23:18.820 --> 01:23:19.180
oder,

01:23:19.380 --> 01:23:19.580
äh,

01:23:19.640 --> 01:23:19.800
genau,

01:23:19.940 --> 01:23:21.860
und das Ganze geht mit Keyword-Argumenten genauso,

01:23:22.160 --> 01:23:23.280
nur dass dann halt nicht Stern ist,

01:23:23.340 --> 01:23:23.720
sondern Stern,

01:23:23.820 --> 01:23:24.020
Stern,

01:23:24.600 --> 01:23:25.960
und damit lassen sich halt sehr,

01:23:26.100 --> 01:23:26.460
sehr leicht,

01:23:26.580 --> 01:23:26.960
ähm,

01:23:27.480 --> 01:23:28.640
zum Beispiel Dicts in,

01:23:28.880 --> 01:23:29.140
äh,

01:23:29.600 --> 01:23:30.800
Keyword-Argumente verwandeln,

01:23:30.940 --> 01:23:32.380
und Keyword-Argumente in Dicts,

01:23:33.260 --> 01:23:34.780
was halt manchmal sehr praktisch ist,

01:23:34.780 --> 01:23:35.060
ja,

01:23:35.820 --> 01:23:36.060
äh,

01:23:36.120 --> 01:23:37.520
und eine Vielschreibarbeit auch Sport,

01:23:38.220 --> 01:23:38.780
ja.

01:23:41.280 --> 01:23:41.640
Cool.

01:23:42.420 --> 01:23:43.120
Jetzt haben wir noch zwei Sachen,

01:23:43.240 --> 01:23:44.680
die noch ein bisschen in diese Funktionen reingehen,

01:23:44.760 --> 01:23:45.020
zweimal,

01:23:45.180 --> 01:23:45.900
wir haben ja Funktionen,

01:23:45.940 --> 01:23:46.820
jetzt jede Menge so Sachen,

01:23:47.300 --> 01:23:47.500
ähm,

01:23:47.560 --> 01:23:47.800
dann,

01:23:47.880 --> 01:23:48.700
was ist eine Lambda-Funktion,

01:23:48.780 --> 01:23:49.400
was macht die denn dann?

01:23:50.320 --> 01:23:50.560
Haben wir,

01:23:50.620 --> 01:23:50.760
glaube ich,

01:23:50.780 --> 01:23:51.700
auch schon einmal kurz besprochen,

01:23:51.840 --> 01:23:51.980
aber,

01:23:52.320 --> 01:23:52.340
äh,

01:23:52.340 --> 01:23:52.580
mhm,

01:23:52.640 --> 01:23:53.720
ist eigentlich nichts Besonderes,

01:23:53.800 --> 01:23:53.980
ist,

01:23:54.140 --> 01:23:54.500
äh,

01:23:54.840 --> 01:23:56.500
eine Funktion wie jede andere,

01:23:56.640 --> 01:23:59.400
also was halt in Python nicht so richtig schick geht,

01:24:00.140 --> 01:24:00.760
ich meine ja auch,

01:24:00.840 --> 01:24:01.260
äh,

01:24:01.820 --> 01:24:02.540
ein bisschen JavaScript,

01:24:02.540 --> 01:24:04.600
und das ist da so schon ein Stückchen,

01:24:04.600 --> 01:24:04.860
äh,

01:24:04.880 --> 01:24:05.580
eleganter vielleicht,

01:24:06.420 --> 01:24:06.660
äh,

01:24:06.740 --> 01:24:06.900
oder,

01:24:07.060 --> 01:24:08.460
also was es in Python so nicht gibt,

01:24:08.520 --> 01:24:09.460
sind so anonyme Blöcke,

01:24:09.640 --> 01:24:10.540
oder anonyme Funktionen,

01:24:11.400 --> 01:24:12.140
über mehrere Zeilen,

01:24:12.180 --> 01:24:12.520
oder sowas,

01:24:13.400 --> 01:24:14.740
sondern da gibt's halt Lambda,

01:24:15.120 --> 01:24:15.360
äh,

01:24:15.820 --> 01:24:16.120
äh,

01:24:16.120 --> 01:24:16.880
äh,

01:24:17.100 --> 01:24:17.500
also der,

01:24:17.660 --> 01:24:18.380
warum muss das überhaupt sein,

01:24:18.440 --> 01:24:19.220
wofür braucht man sowas?

01:24:19.360 --> 01:24:19.520
Ja,

01:24:19.680 --> 01:24:20.560
es gibt oft,

01:24:20.620 --> 01:24:20.820
äh,

01:24:20.860 --> 01:24:22.720
irgendwie Situationen,

01:24:22.740 --> 01:24:23.140
wo man,

01:24:23.340 --> 01:24:25.840
eine Funktion übergeben möchte,

01:24:26.840 --> 01:24:27.760
äh,

01:24:27.880 --> 01:24:28.360
irgendwo hin,

01:24:29.340 --> 01:24:30.660
aber die sonst nicht braucht.

01:24:31.620 --> 01:24:31.900
Also,

01:24:32.220 --> 01:24:32.720
ähm,

01:24:32.720 --> 01:24:34.040
ein Beispiel wäre jetzt,

01:24:34.400 --> 01:24:34.400


01:24:34.400 --> 01:24:34.880
irgendwie,

01:24:35.500 --> 01:24:35.880
wenn man,

01:24:36.180 --> 01:24:36.620
äh,

01:24:36.860 --> 01:24:37.540
irgendwas mit,

01:24:37.620 --> 01:24:37.780
mit,

01:24:37.900 --> 01:24:38.500
äh,

01:24:39.500 --> 01:24:40.740
mit NumPy-Arrays macht,

01:24:40.860 --> 01:24:41.220
oder so,

01:24:41.360 --> 01:24:41.480
oder,

01:24:41.560 --> 01:24:42.340
oder DataFrames,

01:24:42.940 --> 01:24:43.380
äh,

01:24:43.480 --> 01:24:44.340
da ist es ja so,

01:24:44.400 --> 01:24:45.940
dass man eigentlich keine Vorschleifen,

01:24:46.320 --> 01:24:46.520
äh,

01:24:46.560 --> 01:24:47.200
nicht per Vorschleife,

01:24:47.200 --> 01:24:48.020
über irgendwas iterieren,

01:24:48.200 --> 01:24:48.420
äh,

01:24:48.420 --> 01:24:48.700
kann,

01:24:48.820 --> 01:24:50.680
weil Vorschleifen super langsam sind,

01:24:50.740 --> 01:24:51.020
im Fallen.

01:24:51.820 --> 01:24:51.940
Ja,

01:24:51.940 --> 01:24:52.800
das jetzt nicht heißen soll,

01:24:52.880 --> 01:24:53.340
das finde ich nicht,

01:24:53.400 --> 01:24:53.480
weil,

01:24:53.700 --> 01:24:53.860
so,

01:24:53.980 --> 01:24:54.120
äh,

01:24:54.120 --> 01:24:55.420
Vorschleifen sind halt schon gut,

01:24:55.500 --> 01:24:56.240
aber wenn man jetzt über eine,

01:24:56.540 --> 01:24:59.100
ein Array mit irgendwie ein paar Millionen Einträgen iteriert,

01:24:59.160 --> 01:25:01.100
dann will man das vielleicht nicht als Vorschleife hinschreiben,

01:25:01.180 --> 01:25:01.380
sondern,

01:25:01.760 --> 01:25:02.440
was man dann hinschreibt,

01:25:02.520 --> 01:25:03.320
ist halt irgendwas,

01:25:03.580 --> 01:25:04.920
DataFrame.apply,

01:25:05.040 --> 01:25:06.100
und dann übergibt man eine Funktion,

01:25:07.160 --> 01:25:08.000
die dann halt,

01:25:08.500 --> 01:25:08.920
das macht,

01:25:08.980 --> 01:25:12.260
was man jetzt eigentlich im Body einer Vorschleife gerne gemacht hätte,

01:25:12.400 --> 01:25:13.500
aber die man ja nicht hinschreiben kann.

01:25:14.340 --> 01:25:16.160
Diese Funktion hat aber sonst keinen Zweck,

01:25:16.300 --> 01:25:16.760
die ist nicht,

01:25:16.760 --> 01:25:17.020
die,

01:25:17.140 --> 01:25:18.380
an anderer Stelle braucht man die nicht,

01:25:18.460 --> 01:25:18.960
weil eigentlich,

01:25:19.080 --> 01:25:19.940
was man hätte hinschreiben wollen,

01:25:20.000 --> 01:25:20.860
wäre eine Vorschleife gewesen,

01:25:21.120 --> 01:25:21.460
und dann,

01:25:22.040 --> 01:25:22.180
das,

01:25:22.280 --> 01:25:23.240
was man mit dieser Vorschleife macht,

01:25:23.280 --> 01:25:23.740
halt machen,

01:25:24.420 --> 01:25:25.440
aber das geht halt nicht,

01:25:25.560 --> 01:25:25.820
daher,

01:25:26.080 --> 01:25:26.420
äh,

01:25:27.460 --> 01:25:27.620
ja,

01:25:27.840 --> 01:25:30.280
braucht man halt jetzt diese temporäre Funktion,

01:25:30.360 --> 01:25:31.120
der man jetzt auch gar keinen,

01:25:31.180 --> 01:25:32.320
gar nicht unbedingt einen Namen geben will,

01:25:32.380 --> 01:25:32.520
weil,

01:25:32.540 --> 01:25:34.060
man möchte halt quasi die Quadrate haben,

01:25:34.120 --> 01:25:35.140
von einer Spalte oder sowas.

01:25:35.300 --> 01:25:35.780
Irgendwie sowas,

01:25:35.820 --> 01:25:36.940
oder rechnet halt irgendwas aus,

01:25:37.000 --> 01:25:38.160
auf jedem Element oder so,

01:25:38.220 --> 01:25:38.500
und dann,

01:25:38.680 --> 01:25:38.980
äh,

01:25:39.060 --> 01:25:39.240
genau.

01:25:41.480 --> 01:25:41.800
Lambda,

01:25:42.100 --> 01:25:42.980
äh,

01:25:42.980 --> 01:25:43.900
gibt halt sozusagen,

01:25:44.120 --> 01:25:44.800
also Lambda X,

01:25:45.200 --> 01:25:45.840
Doppelpunkt,

01:25:46.420 --> 01:25:46.740
äh,

01:25:46.760 --> 01:25:46.940
äh,

01:25:47.140 --> 01:25:47.380
X,

01:25:47.540 --> 01:25:48.580
äh,

01:25:48.680 --> 01:25:49.680
zum Quadrat oder sowas,

01:25:50.440 --> 01:25:50.980
würde halt,

01:25:51.080 --> 01:25:52.440
ein Argument nehmen,

01:25:52.680 --> 01:25:54.600
und dieses Argument mit sich selbst multiplizieren,

01:25:54.660 --> 01:25:55.320
und dann wieder zurückgeben.

01:25:56.060 --> 01:25:56.300
Nur,

01:25:56.360 --> 01:25:56.780
dass man halt,

01:25:56.860 --> 01:25:57.180
äh,

01:25:57.280 --> 01:25:58.240
das Return weglassen,

01:25:58.540 --> 01:25:59.300
muss,

01:25:59.520 --> 01:26:00.700
also Return kann man nicht hinschreiben,

01:26:00.860 --> 01:26:01.320
in der Lambda,

01:26:01.900 --> 01:26:02.540
sondern ist es halt,

01:26:03.320 --> 01:26:03.600
das,

01:26:03.740 --> 01:26:04.400
was halt man,

01:26:04.600 --> 01:26:04.980
das Letzte,

01:26:05.060 --> 01:26:05.620
was irgendwie,

01:26:06.380 --> 01:26:06.940
das ist implizit,

01:26:07.000 --> 01:26:07.480
nicht explizit,

01:26:07.600 --> 01:26:07.900
ja,

01:26:07.980 --> 01:26:09.540
implizit wird das halt einfach zurückgegeben.

01:26:10.260 --> 01:26:10.580
Und,

01:26:10.680 --> 01:26:11.080
äh,

01:26:11.280 --> 01:26:11.520
ja,

01:26:11.720 --> 01:26:12.340
auch der,

01:26:12.340 --> 01:26:12.420
äh,

01:26:12.780 --> 01:26:12.940
die,

01:26:13.120 --> 01:26:14.540
die Argumentübergabe ist ein bisschen anders,

01:26:14.660 --> 01:26:14.740
ne,

01:26:14.780 --> 01:26:16.160
es ist halt nicht irgendwie Klammer auf,

01:26:16.280 --> 01:26:16.540
und dann,

01:26:16.760 --> 01:26:16.880
sowas,

01:26:16.920 --> 01:26:18.560
sondern es ist halt einfach Leerzeichen,

01:26:18.820 --> 01:26:19.660
und dann Liste der,

01:26:19.760 --> 01:26:20.760
Argumente,

01:26:20.860 --> 01:26:21.340
Doppelpunkt,

01:26:21.480 --> 01:26:21.700
äh,

01:26:22.000 --> 01:26:23.280
und das wird halt implizit,

01:26:23.400 --> 01:26:23.740
äh,

01:26:23.840 --> 01:26:24.320
passiert das halt,

01:26:24.380 --> 01:26:25.620
und es kann alles nur in einer Zeile stehen,

01:26:25.700 --> 01:26:26.100
es darf nicht,

01:26:26.300 --> 01:26:26.580
äh,

01:26:27.440 --> 01:26:28.460
darf nicht mehrere Zeilen.

01:26:28.480 --> 01:26:29.580
Aber so ein bisschen hässlich ist es aber doch.

01:26:29.580 --> 01:26:30.400
Es ist ein bisschen hässlich,

01:26:30.480 --> 01:26:30.600
ja.

01:26:31.160 --> 01:26:32.180
Auf der anderen Seite ist es so,

01:26:32.200 --> 01:26:33.120
wenn das komplizierter wird,

01:26:33.160 --> 01:26:34.120
man muss das ja nicht so machen,

01:26:34.180 --> 01:26:36.060
man kann auch tatsächlich eine Funktion hinschreiben,

01:26:36.120 --> 01:26:37.440
die man einfach irgendwie nennt.

01:26:39.240 --> 01:26:39.860
Kann man ja auch sagen,

01:26:39.960 --> 01:26:40.260
irgendwie,

01:26:40.260 --> 01:26:40.580
äh,

01:26:40.820 --> 01:26:41.360
rechne mir,

01:26:41.680 --> 01:26:42.800
irgendwie das Quadrat aus,

01:26:42.900 --> 01:26:43.200
oder so,

01:26:43.360 --> 01:26:43.700
äh,

01:26:43.700 --> 01:26:44.220
Funktion,

01:26:44.820 --> 01:26:46.160
und dann schreibt man halt in diese Funktion,

01:26:46.180 --> 01:26:47.220
dann kann man ja auch mehrere Zeilen schreiben,

01:26:47.260 --> 01:26:47.960
die schreibt man dann da rein,

01:26:48.180 --> 01:26:49.440
und dann übergibt man das Ding halt.

01:26:49.900 --> 01:26:50.440
Der Lambda-Funktion.

01:26:51.640 --> 01:26:52.280
Nicht der Lambda,

01:26:52.420 --> 01:26:52.640
sondern,

01:26:52.740 --> 01:26:54.220
übergibt das statt der Lambda-Funktion,

01:26:54.300 --> 01:26:55.180
weil es ist genau das Gleiche.

01:26:55.440 --> 01:26:55.800
Es ist halt,

01:26:56.120 --> 01:26:56.440
das,

01:26:56.540 --> 01:26:57.700
was man zurückbekommt von diesem Lambda,

01:26:57.820 --> 01:26:58.220
ist auch nicht,

01:26:58.220 --> 01:26:58.240
Das heißt,

01:26:58.240 --> 01:26:59.540
Lambda braucht man eigentlich überhaupt nicht,

01:26:59.600 --> 01:27:00.100
weil das irgendwie,

01:27:00.180 --> 01:27:00.280
Nee,

01:27:00.300 --> 01:27:00.760
man braucht es,

01:27:00.880 --> 01:27:01.360
braucht es nicht,

01:27:01.600 --> 01:27:01.800
äh,

01:27:01.800 --> 01:27:03.200
ist es halt manchmal auch,

01:27:03.320 --> 01:27:03.560
äh,

01:27:03.560 --> 01:27:03.820
nett,

01:27:04.000 --> 01:27:05.100
das so hinschreiben zu können,

01:27:05.260 --> 01:27:06.400
aber wirklich brauchen tut man es nicht,

01:27:06.480 --> 01:27:06.600
nee.

01:27:07.720 --> 01:27:07.760
Ähm,

01:27:07.760 --> 01:27:08.660
Spart ein bisschen Schreibarbeit,

01:27:08.660 --> 01:27:09.960
für zum Beispiel so einfache Operationen,

01:27:10.000 --> 01:27:10.880
wie einfach Quadrat zu geben,

01:27:10.960 --> 01:27:12.480
dann kann man einfach das Lambda in die Teile schreiben,

01:27:12.560 --> 01:27:13.600
wenn man es nicht wieder sonst braucht,

01:27:13.680 --> 01:27:13.800
dann.

01:27:14.280 --> 01:27:14.440
Genau,

01:27:14.500 --> 01:27:15.080
weil du hast halt,

01:27:15.240 --> 01:27:15.360
äh,

01:27:15.360 --> 01:27:15.580
wenn du,

01:27:15.660 --> 01:27:16.960
wenn du Funktionen hinschreibst in Python,

01:27:17.120 --> 01:27:18.960
immer einen gewissen Zeilen-Overhead,

01:27:19.060 --> 01:27:19.300
weil,

01:27:19.480 --> 01:27:19.720
äh,

01:27:19.780 --> 01:27:20.020
naja,

01:27:20.320 --> 01:27:20.440
da,

01:27:20.540 --> 01:27:20.860
da,

01:27:20.860 --> 01:27:21.100
da,

01:27:21.100 --> 01:27:21.240
da die,

01:27:21.240 --> 01:27:22.880
da die Umbrüche,

01:27:23.040 --> 01:27:23.260
äh,

01:27:23.260 --> 01:27:24.380
syntaktisch relevant sind,

01:27:24.420 --> 01:27:25.060
und die Eindrückung,

01:27:25.220 --> 01:27:25.400
äh,

01:27:25.400 --> 01:27:25.900
ist es halt so,

01:27:26.000 --> 01:27:27.360
dass du da auf jeden Fall immer mehrere,

01:27:27.520 --> 01:27:29.500
mindestens mal zwei Zeilen für hinschreiben musst,

01:27:30.760 --> 01:27:30.960
ja,

01:27:31.080 --> 01:27:32.800
und mit Lambda kannst du es auch in einer Zeile hinschreiben.

01:27:32.800 --> 01:27:34.520
Und wenn das wirklich eine ganz simple Geschichte ist,

01:27:34.600 --> 01:27:34.820
dann,

01:27:34.900 --> 01:27:35.180
äh,

01:27:35.240 --> 01:27:35.960
willst du vielleicht keine,

01:27:36.080 --> 01:27:37.580
nicht deswegen eine Funktion definieren,

01:27:37.660 --> 01:27:37.820
sondern,

01:27:38.920 --> 01:27:39.060
ja,

01:27:39.260 --> 01:27:39.560
aber,

01:27:39.740 --> 01:27:40.020
äh,

01:27:40.160 --> 01:27:42.360
letztlich kann man dafür auch ganz normale Funktionen verwenden,

01:27:42.780 --> 01:27:43.100
ähm,

01:27:43.600 --> 01:27:43.900
und,

01:27:43.980 --> 01:27:44.120
äh,

01:27:44.120 --> 01:27:45.040
was ja an Python auch geht,

01:27:45.100 --> 01:27:45.680
was auch schön ist,

01:27:45.740 --> 01:27:46.280
du kannst halt,

01:27:46.360 --> 01:27:46.600
äh,

01:27:46.680 --> 01:27:48.560
innerhalb von Funktionen auch wieder Funktionen definieren,

01:27:48.660 --> 01:27:48.740
ne,

01:27:48.800 --> 01:27:49.080
also,

01:27:49.220 --> 01:27:51.040
du musst ja nicht die Funktionen dann außerhalb der Funktionen,

01:27:51.140 --> 01:27:51.300
das heißt,

01:27:51.340 --> 01:27:53.220
du kannst die Funktionen auch direkt da an die Stelle schreiben,

01:27:53.380 --> 01:27:54.780
wo du sie verwenden willst.

01:27:54.940 --> 01:27:55.760
Wann macht man das denn,

01:27:55.900 --> 01:27:56.000
also,

01:27:56.100 --> 01:27:57.480
dass man so schachtelte Funktionen macht?

01:27:57.700 --> 01:27:57.900
Ja,

01:27:57.980 --> 01:27:58.180
eben,

01:27:58.180 --> 01:27:58.540
zum Beispiel,

01:27:58.640 --> 01:28:01.300
wenn du halt eine Funktion sonst nirgendwo verwenden möchtest,

01:28:01.380 --> 01:28:02.020
und möchtest halt,

01:28:02.120 --> 01:28:03.020
aber du brauchst eine Funktion,

01:28:04.180 --> 01:28:04.900
da sind wir wieder bei,

01:28:04.940 --> 01:28:05.740
zum Beispiel bei Clojure,

01:28:05.840 --> 01:28:05.960
äh,

01:28:05.960 --> 01:28:06.440
Clojures,

01:28:06.600 --> 01:28:07.400
brauchst du das halt,

01:28:07.900 --> 01:28:09.160
wo du eine Funktion zurückgibst,

01:28:09.460 --> 01:28:11.140
die halt Zugriff auf den Scope,

01:28:12.420 --> 01:28:12.820
äh,

01:28:12.920 --> 01:28:13.100
äh,

01:28:13.100 --> 01:28:13.880
auf Variablen hat,

01:28:13.940 --> 01:28:15.160
die im Scope dieser Funktion liegen.

01:28:16.280 --> 01:28:16.440
Ja,

01:28:16.520 --> 01:28:16.720
also,

01:28:16.760 --> 01:28:17.020
wenn du,

01:28:17.620 --> 01:28:18.060
ähm,

01:28:18.800 --> 01:28:19.800
also Clojure ist quasi,

01:28:20.180 --> 01:28:20.420
sozusagen,

01:28:20.500 --> 01:28:21.100
du hast eine Funktion,

01:28:21.560 --> 01:28:24.360
und in dieser Funktion gibst du jetzt,

01:28:24.420 --> 01:28:25.740
du gibst jetzt eine andere Funktion zurück.

01:28:27.100 --> 01:28:27.740
Eine innere,

01:28:27.900 --> 01:28:28.160
äh,

01:28:28.180 --> 01:28:28.720
innere Funktion,

01:28:28.800 --> 01:28:29.080
sozusagen.

01:28:29.500 --> 01:28:30.100
Und du möchtest,

01:28:30.220 --> 01:28:33.460
dass diese Funktion Zugriff hat auf eine Variable,

01:28:33.600 --> 01:28:35.700
die zum Beispiel innerhalb der äußeren Funktion definiert ist.

01:28:35.980 --> 01:28:37.720
Zum Beispiel einen Counter,

01:28:37.820 --> 01:28:39.060
der mit irgendwas initialisiert wird.

01:28:39.140 --> 01:28:39.240
Also,

01:28:39.380 --> 01:28:39.800
genau,

01:28:39.800 --> 01:28:40.640
das Beispiel können wir mal nehmen,

01:28:40.700 --> 01:28:41.360
sagen wir mal,

01:28:41.580 --> 01:28:41.880
def,

01:28:42.120 --> 01:28:42.980
äh,

01:28:43.720 --> 01:28:45.800
äh,

01:28:46.560 --> 01:28:47.020
äh,

01:28:47.020 --> 01:28:47.640
äh,

01:28:47.640 --> 01:28:47.700
äh,

01:28:47.700 --> 01:28:47.720
äh,

01:28:47.720 --> 01:28:47.740
äh,

01:28:47.740 --> 01:28:47.760
äh,

01:28:47.760 --> 01:28:47.780
äh,

01:28:47.780 --> 01:28:47.820
äh,

01:28:47.820 --> 01:28:47.880
äh,

01:28:47.880 --> 01:28:47.900
äh,

01:28:47.900 --> 01:28:47.920
äh,

01:28:47.920 --> 01:28:47.940
äh,

01:28:47.940 --> 01:28:47.960
äh,

01:28:47.960 --> 01:28:47.980
äh,

01:28:47.980 --> 01:28:48.160
äh,

01:28:48.160 --> 01:28:48.220
äh,

01:28:48.220 --> 01:28:48.240
äh,

01:28:48.240 --> 01:28:48.260
äh,

01:28:48.260 --> 01:28:48.320
äh,

01:28:48.320 --> 01:28:48.340
äh,

01:28:48.340 --> 01:28:48.440
äh,

01:28:48.440 --> 01:28:48.540
äh,

01:28:48.540 --> 01:28:48.520
äh,

01:28:48.540 --> 01:28:58.540
äh,

01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:28:58.540


01:28:58.540 --> 01:29:03.680
Y

01:29:03.680 --> 01:29:05.480
Klammer zu, Doppelpunkt

01:29:05.480 --> 01:29:08.400
und dann

01:29:08.400 --> 01:29:09.480
Return

01:29:09.480 --> 01:29:11.080
Range

01:29:11.080 --> 01:29:12.520
Counter,

01:29:12.840 --> 01:29:15.720
Counter,

01:29:16.200 --> 01:29:16.880
Y oder so.

01:29:17.180 --> 01:29:19.320
Es geht darum, wenn du sagen möchtest,

01:29:19.420 --> 01:29:21.600
ab wann etwas zählen soll, dann möchtest du

01:29:21.600 --> 01:29:22.520
diesen Counter ja

01:29:22.520 --> 01:29:25.600
diesen State wieder halten irgendwo

01:29:25.600 --> 01:29:27.520
und du möchtest ihn irgendwo halten, wo jetzt die

01:29:27.520 --> 01:29:29.400
innere Funktion, die du zurückgibst, die jetzt dann

01:29:29.400 --> 01:29:31.060
irgendwie zum Beispiel irgendwas iteriert oder so,

01:29:31.500 --> 01:29:32.840
darauf zugreifen kann. Aber

01:29:32.840 --> 01:29:35.940
du willst es sonst nicht manipulierbar

01:29:35.940 --> 01:29:37.720
haben. Das ist auch eine, damit kannst du

01:29:37.720 --> 01:29:39.400
tatsächlich dann auch

01:29:39.400 --> 01:29:41.860
Werte so wegverstecken,

01:29:41.940 --> 01:29:42.960
dass man da nicht mehr rankommt.

01:29:43.320 --> 01:29:44.840
Jedenfalls nicht. Also man kommt schon, aber

01:29:44.840 --> 01:29:47.300
dann wird es schwierig. Nicht mehr so einfach.

01:29:49.160 --> 01:29:49.440
Und

01:29:49.440 --> 01:29:51.740
ja, dafür braucht man

01:29:51.740 --> 01:29:53.580
zum Beispiel so innere Funktionen. Ohne die ginge das

01:29:53.580 --> 01:29:54.240
gar nicht richtig.

01:29:55.120 --> 01:29:56.820
Und das ist eine Closure.

01:29:57.520 --> 01:29:59.160
Also, dass sozusagen die

01:29:59.160 --> 01:30:01.020
innere Funktion hat Zugriff auf den Counter,

01:30:01.340 --> 01:30:02.500
den ich irgendwann mal übergeben habe.

01:30:03.420 --> 01:30:05.080
Aber, weil

01:30:05.080 --> 01:30:07.200
die innere Funktion ja im gleichen Scope ist,

01:30:07.420 --> 01:30:08.140
wie das Ding,

01:30:09.100 --> 01:30:11.360
wie das, was ich ursprünglich mal gesetzt habe.

01:30:13.460 --> 01:30:15.280
Ansonsten komme ich da von außen aber nicht mehr ran.

01:30:15.340 --> 01:30:16.800
Wenn ich jetzt nur die zurückgegebene

01:30:16.800 --> 01:30:18.960
Funktion habe,

01:30:19.440 --> 01:30:21.200
dann komme ich an den Counterwert

01:30:21.200 --> 01:30:21.760
nicht mehr ran.

01:30:23.120 --> 01:30:25.180
Und dann kann ich halt die äußere Funktion verwenden, um sozusagen

01:30:25.180 --> 01:30:27.360
einen Counter, der ab 5 zählt, immer zurück.

01:30:27.520 --> 01:30:28.980
Oder gib mir einen Counter, der ab 10 zählt, immer.

01:30:29.380 --> 01:30:31.600
Und das 10 oder 5 steht dann halt eben in dieser

01:30:31.600 --> 01:30:33.460
Ja, ist ein etwas

01:30:33.460 --> 01:30:34.360
komplizierteres Konzept.

01:30:35.020 --> 01:30:37.260
Aber das ist halt auch die Art, wie dann irgendwie

01:30:37.260 --> 01:30:39.160
Dekoratoren und

01:30:39.160 --> 01:30:43.460
Context Manager und so funktionieren.

01:30:43.780 --> 01:30:44.500
Die haben da

01:30:44.500 --> 01:30:46.520
Dinge in der Richtung.

01:30:47.720 --> 01:30:47.880
Ja.

01:30:49.620 --> 01:30:51.160
Genau. Aber das ist eigentlich,

01:30:51.280 --> 01:30:53.320
das finde ich auch sehr schön, dass man halt

01:30:53.320 --> 01:30:54.360
in Funktionen auch locker

01:30:54.360 --> 01:30:57.280
Funktionen definieren kann. Und man kann auch Klassen innerhalb von Klassen

01:30:57.280 --> 01:30:59.260
definieren und so. Also das geht

01:30:59.260 --> 01:31:00.000
einfach problemlos.

01:31:02.020 --> 01:31:03.420
Klingt nach viel Konfusion

01:31:03.420 --> 01:31:05.240
für die Anfängerkurve, die jetzt gerade da ist.

01:31:05.240 --> 01:31:06.700
Ja, ja, ja. Vielleicht sollte man, genau,

01:31:07.180 --> 01:31:08.660
vielleicht sollte man das natürlich auch.

01:31:10.560 --> 01:31:10.920
Ja.

01:31:11.160 --> 01:31:12.680
Ich habe jetzt noch eine Basisfrage.

01:31:12.920 --> 01:31:13.980
Was ist der Unterschied von einer

01:31:13.980 --> 01:31:16.660
Zugreifung von gleich gleich oder ist, also

01:31:16.660 --> 01:31:18.940
nicht zugreifend, sondern eine Abfrage.

01:31:19.060 --> 01:31:21.240
Würdest du jetzt etwas vergleichen, ein gleich gleich oder ein ist?

01:31:21.380 --> 01:31:23.120
Also zum Beispiel A gleich gleich B, A ist B.

01:31:23.680 --> 01:31:24.880
Etwas ist gleich gleich None.

01:31:25.360 --> 01:31:25.940
Ist None.

01:31:26.740 --> 01:31:27.180
Ja.

01:31:27.280 --> 01:31:28.820
Ähm, also

01:31:28.820 --> 01:31:31.140
äh, wenn

01:31:31.140 --> 01:31:33.380
ich gleich gleich verwendere,

01:31:33.700 --> 01:31:35.260
also gleich ist natürlich irgendwie

01:31:35.260 --> 01:31:37.000
Zuweisung, aber gleich gleich,

01:31:37.140 --> 01:31:38.280
da wird halt der Wert verglichen.

01:31:39.160 --> 01:31:41.080
Also, ähm,

01:31:41.980 --> 01:31:45.180
und bei ist wird

01:31:45.180 --> 01:31:47.460
verglichen, ob es das gleiche Objekt ist.

01:31:48.420 --> 01:31:49.300
Und deswegen zahlt man zum Beispiel

01:31:49.300 --> 01:31:51.220
bei None, sagt man immer ist None, weil

01:31:51.220 --> 01:31:52.720
es nur ein None-Objekt gibt. Genau.

01:31:52.820 --> 01:31:54.360
None ist ein Singleton. Ja.

01:31:54.360 --> 01:31:56.500
Ja. Und deswegen kann ich halt

01:31:56.500 --> 01:31:57.120
so testen,

01:31:57.280 --> 01:31:58.880
äh, ob es wirklich None ist.

01:31:59.580 --> 01:32:00.740
True und False sind auch Singleton.

01:32:02.200 --> 01:32:02.640
Äh.

01:32:07.260 --> 01:32:07.620
Hm.

01:32:08.680 --> 01:32:09.000
Hm.

01:32:09.720 --> 01:32:11.020
Ja, ich, äh,

01:32:11.140 --> 01:32:13.280
bin ich mir jetzt nicht so ganz sicher, aber ich glaube schon.

01:32:14.500 --> 01:32:15.600
Äh, ich weiß

01:32:15.600 --> 01:32:17.600
aber nicht genau. Ja, so müsste wahrscheinlich

01:32:17.600 --> 01:32:19.120
so sein, ne? Das könnte eigentlich gar nicht anders.

01:32:20.560 --> 01:32:21.800
Okay, das heißt, ihr müsst halt tatsächlich,

01:32:21.880 --> 01:32:23.280
wenn es ist, immer genau das Objekt.

01:32:23.580 --> 01:32:24.140
Das heißt, man kann...

01:32:24.140 --> 01:32:27.120
Ja, ja, aber man kann das auch zuweisen.

01:32:27.120 --> 01:32:27.240
Ja.

01:32:27.280 --> 01:32:28.760
Also es ist auch ganz böse. Man kann

01:32:28.760 --> 01:32:31.260
True und False auch noch anders belegen. Also,

01:32:31.380 --> 01:32:33.080
hm, müsste man mal nachgucken.

01:32:33.240 --> 01:32:35.280
Ja, das, was irgendwie spannend ist,

01:32:35.320 --> 01:32:37.320
weil jetzt, wir haben ja so ein paar Mal über so Sachen geredet,

01:32:37.380 --> 01:32:39.040
was jetzt irgendwie Klassen sind und Objekte und Typen,

01:32:39.120 --> 01:32:41.120
dass alle Sachen in Python irgendwelche Objekte sind,

01:32:41.200 --> 01:32:43.140
irgendwelche Typen sind. Und dann, ähm, da habe ich mich

01:32:43.140 --> 01:32:44.940
irgendwie gefragt, ob, äh,

01:32:44.980 --> 01:32:47.240
jetzt nicht die ganzen Zuweisungen, also man kann jetzt irgendwie Typen umwandeln,

01:32:47.320 --> 01:32:49.100
ja, also, ne, von Integer auf String oder sowas.

01:32:49.240 --> 01:32:51.280
Ja. Ob das nicht halt auch, äh,

01:32:51.920 --> 01:32:53.380
Klasse dann eigentlich ist, die man halt

01:32:53.380 --> 01:32:54.780
nimmt, weil das halt ein Typ ist, ein Objekt ist.

01:32:54.780 --> 01:32:56.680
Deswegen müsste das eigentlich großgeschrieben werden,

01:32:56.680 --> 01:32:58.720
weil man halt eine Instanz eines Objektes ändert

01:32:58.720 --> 01:33:00.240
und eine Instanz eines Objektes erzeugt.

01:33:00.480 --> 01:33:02.380
Zum Beispiel von einer Instanz eines Objektes String

01:33:02.380 --> 01:33:04.020
in eine Instanz eines Objektes Integer wechselt.

01:33:04.060 --> 01:33:05.960
Wenn man ein Int vorstellt, es müsste ein bisschen großes Int sein,

01:33:06.720 --> 01:33:08.940
dann an der Stelle irgendwie, war ich da ein bisschen verwirrt.

01:33:09.060 --> 01:33:10.520
Ja, ich, äh, also,

01:33:10.680 --> 01:33:12.780
da, ich rate jetzt mal, woher das kommt.

01:33:12.880 --> 01:33:14.160
Ich weiß es ehrlich gesagt auch nicht so genau.

01:33:14.720 --> 01:33:16.720
Ähm, vielleicht weiß das jemand

01:33:16.720 --> 01:33:18.480
besser und kann mich da korrigieren, aber ich

01:33:18.480 --> 01:33:20.220
denke mal, das liegt daran, dass

01:33:20.220 --> 01:33:21.460
das Build-Ins sind.

01:33:22.600 --> 01:33:23.440
Also ja, eigentlich

01:33:23.440 --> 01:33:25.240
die Konvention in Python ist so, wenn das eine Klasse ist,

01:33:25.360 --> 01:33:26.360
dann schreibt man das halt groß.

01:33:26.680 --> 01:33:29.380
Ja, aber, äh,

01:33:29.660 --> 01:33:31.340
ich glaube, alle Build-Ins sind klein.

01:33:32.480 --> 01:33:33.740
Und da das Build-Ins sind,

01:33:33.920 --> 01:33:34.620
äh,

01:33:35.500 --> 01:33:35.860
wird die Konvention...

01:33:35.860 --> 01:33:39.200
Das ist wichtiger, weil es gibt nicht so viele Build-Ins.

01:33:39.200 --> 01:33:41.020
Aber richtig wäre es tatsächlich, dass man, wenn man,

01:33:41.140 --> 01:33:43.300
zum Verständnis vielleicht, dass man irgendwie, wenn man

01:33:43.300 --> 01:33:45.500
einen Typ ändert, einer Variable

01:33:45.500 --> 01:33:47.240
beispielsweise, dass man einen neuen Instanz,

01:33:47.300 --> 01:33:49.400
eine neue oder eine andere Klasse erzeugt.

01:33:49.400 --> 01:33:51.660
Jaja, das ist so, aber das passiert auch tatsächlich.

01:33:51.800 --> 01:33:53.620
Also wenn ich sage int, Klammer auf,

01:33:53.680 --> 01:33:54.420
5, Klammer zu,

01:33:55.200 --> 01:33:56.600
dann wird ein neues Int,

01:33:56.680 --> 01:33:59.240
Job-Objekt erzeugt, genau, mit dem Wort 5.

01:34:00.120 --> 01:34:01.340
Ähm, also es ist tatsächlich,

01:34:01.620 --> 01:34:02.720
ähm, ja, äh,

01:34:03.500 --> 01:34:05.280
auch Dict ist ja in, äh,

01:34:05.480 --> 01:34:06.720
ist ja eine Klasse tatsächlich.

01:34:06.980 --> 01:34:09.320
Ich kann ja auch davon erben und so, sollte ich vielleicht nicht machen, aber,

01:34:09.540 --> 01:34:11.120
äh, auch da, aber

01:34:11.120 --> 01:34:13.400
ich kann davon erben und das funktioniert auch.

01:34:14.180 --> 01:34:14.620
Ähm,

01:34:15.420 --> 01:34:17.440
aber ja, aber ich denke, das hängt damit

01:34:17.440 --> 01:34:19.400
zusammen, dass die Build-Ins halt so Spezialfälle

01:34:19.400 --> 01:34:21.260
sind. Wenn ich die Klassen verwenden möchte,

01:34:21.300 --> 01:34:23.100
für die ganzen Dinger gibt es auch noch richtige Klassen.

01:34:24.360 --> 01:34:25.220
Ähm, zum Beispiel

01:34:25.220 --> 01:34:26.640
für, für, für, äh,

01:34:26.680 --> 01:34:28.780
äh, Dict und List und so

01:34:28.780 --> 01:34:30.260
gibt es User-Dict, User-List.

01:34:31.380 --> 01:34:32.820
Und, äh, auch wenn ich jetzt

01:34:32.820 --> 01:34:34.640
irgendwie selber ein eigenes Dict, das

01:34:34.640 --> 01:34:36.720
Dinge ein bisschen anders macht als ein normales Dict,

01:34:37.260 --> 01:34:39.020
äh, verwenden möchte, dann, ähm,

01:34:39.680 --> 01:34:40.680
sollte ich halt irgendwie

01:34:40.680 --> 01:34:42.560
von User-Dict erben und nicht von, von, von

01:34:42.560 --> 01:34:43.580
einfach nur kleingeschriebenem Dict.

01:34:44.820 --> 01:34:45.020
Ja.

01:34:45.740 --> 01:34:48.200
Dass jeder, wie du das nie, weil sich schon Leute rumgekümmert haben,

01:34:48.280 --> 01:34:50.380
bestimmte Probleme zu entgehen, auf die man dann stößt, wenn man das nicht macht.

01:34:50.520 --> 01:34:51.140
Ja, ja, genau, genau.

01:34:52.460 --> 01:34:53.680
Ähm, ja.

01:34:54.740 --> 01:34:56.280
Ja, jetzt haben wir, wir haben noch jede Menge.

01:34:56.680 --> 01:34:58.660
Ich weiß gar nicht, ob wir das heute in der Folge alles irgendwie unterkriegen.

01:34:59.280 --> 01:35:00.740
Noch ein Anwesender hat gefragt, was denn eine

01:35:00.740 --> 01:35:01.520
Shallow-Copy ist.

01:35:02.500 --> 01:35:02.700
Achso.

01:35:02.700 --> 01:35:04.740
Warum man, äh, wie arbeitet man richtig mit Listen

01:35:04.740 --> 01:35:06.720
im Zusammenhang mit Funktionen? Oder gibt man eine Kopie

01:35:06.720 --> 01:35:08.720
und retournt eine neue Liste? Oder gibt man eine

01:35:08.720 --> 01:35:10.660
Liste und ändert die quasi in Plays?

01:35:11.300 --> 01:35:12.760
Was hat das damit zu tun? Also, irgendwie.

01:35:13.960 --> 01:35:14.360
Ähm,

01:35:14.920 --> 01:35:16.460
ja,

01:35:16.580 --> 01:35:18.700
das ist auch eine eher auf unabständige

01:35:18.700 --> 01:35:20.080
Zielfrage, was man da machen

01:35:20.080 --> 01:35:21.620
möchte.

01:35:23.200 --> 01:35:24.580
Äh, also einmal,

01:35:24.740 --> 01:35:26.660
äh, vielleicht zuerst das mit der, mit der Shallow,

01:35:26.680 --> 01:35:28.720
äh, Kopie, ähm, also die, die

01:35:28.720 --> 01:35:30.620
Frage ist, was, was passiert eigentlich, wenn ich

01:35:30.620 --> 01:35:32.660
jetzt, äh, sozusagen eine Kopie

01:35:32.660 --> 01:35:35.000
von irgendwas machen möchte und, ähm,

01:35:35.900 --> 01:35:36.280
äh,

01:35:38.020 --> 01:35:38.580
äh, weil ich,

01:35:38.700 --> 01:35:40.200
weil ich, äh, warum,

01:35:40.480 --> 01:35:42.600
warum auch immer irgendwie eine zweite Version

01:35:42.600 --> 01:35:44.040
von irgendeiner Datenstruktur brauche oder so.

01:35:44.740 --> 01:35:46.520
Äh, da ist es, wenn ich jetzt, äh,

01:35:46.840 --> 01:35:48.600
die einfach nur kopiere, also wenn ich jetzt,

01:35:48.800 --> 01:35:50.560
also, in, in Python

01:35:50.560 --> 01:35:52.880
habe ich eigentlich immer Referenzen auf, auf solche Datenstrukturen

01:35:52.880 --> 01:35:54.580
in der Hand. Also auch

01:35:54.580 --> 01:35:56.500
die, äh, Übergabe von Sachen ist

01:35:56.500 --> 01:35:58.320
immer bei Referenz, also es gibt ja ein C,

01:35:58.500 --> 01:35:59.820
es ist unter Umständen anders, da gibt es halt,

01:36:00.240 --> 01:36:02.640
kann ich Argumente übergeben, äh,

01:36:02.700 --> 01:36:04.740
als Referenz oder halt als,

01:36:04.900 --> 01:36:06.720
ähm, als, als Wert,

01:36:07.060 --> 01:36:08.140
ja, also, äh,

01:36:08.520 --> 01:36:09.820
also direkt den Wert einfach so.

01:36:10.380 --> 01:36:12.680
Und in Python ist es immer per Referenz.

01:36:13.540 --> 01:36:14.520
Also in

01:36:14.520 --> 01:36:16.480
der Variable, die ich übergebe, steht

01:36:16.480 --> 01:36:18.360
immer sozusagen einfach eine Speicheradresse drin,

01:36:18.560 --> 01:36:20.080
die halt auf das Objekt zeigt, das ich übergebe.

01:36:20.460 --> 01:36:22.580
Und ich übergebe immer nur die Adresse, ich übergebe nicht

01:36:22.580 --> 01:36:24.280
der Funktion das Objekt

01:36:24.280 --> 01:36:24.840
selbst.

01:36:24.840 --> 01:36:26.820
Und, äh,

01:36:26.980 --> 01:36:28.900
jetzt ist es halt so, wenn ich, äh, einfach nur,

01:36:29.100 --> 01:36:30.960
äh, bestimmte Operationen

01:36:30.960 --> 01:36:32.500
duplizieren mir halt jetzt diese Adresse,

01:36:32.920 --> 01:36:34.040
aber nicht den Inhalt dahinter.

01:36:35.020 --> 01:36:36.700
Das heißt, wenn ich jetzt, ich mache eine Kopie davon,

01:36:36.980 --> 01:36:38.940
ich, naja, muss mal überlegen, in welchen Umständen

01:36:38.940 --> 01:36:40.840
ich das hinkriege, ähm,

01:36:42.480 --> 01:36:42.900
wenn ich

01:36:42.900 --> 01:36:43.160
jetzt,

01:36:44.020 --> 01:36:46.720
wenn ich jetzt einfach nur kopie,

01:36:46.920 --> 01:36:47.860
äh, vom,

01:36:49.360 --> 01:36:50.740
ich weiß nicht, ob Kopie

01:36:50.740 --> 01:36:52.320
ein Bild ist, aber wenn ich einfach nur sage,

01:36:52.320 --> 01:36:54.460
äh, kopier mir das mal, dann kann es sein, dass es mir nur

01:36:54.460 --> 01:36:56.320
die Referenz kopiert wird. Das heißt, mir wird halt

01:36:56.320 --> 01:36:58.520
die, äh, Speicheradresse in eine andere Variable kopiert,

01:36:58.820 --> 01:37:00.460
aber wenn ich jetzt irgendwas am Inhalt einer Liste

01:37:00.460 --> 01:37:02.400
oder so ändere, dann ist das in beiden

01:37:02.400 --> 01:37:04.260
Listen geändert. Und das ist unter Umständen

01:37:04.260 --> 01:37:05.980
nicht so intuitiv. Vielleicht.

01:37:06.500 --> 01:37:08.040
Hätte man jetzt nicht so mit gerechnet, sondern,

01:37:08.960 --> 01:37:10.360
äh, man hätte damit gerechnet, dass ich jetzt

01:37:10.360 --> 01:37:12.520
zwei Listen habe, die, äh, im Hauptspeicher

01:37:12.520 --> 01:37:14.140
an zwei unterschiedlichen Stellen liegen.

01:37:15.440 --> 01:37:16.520
Und eine Shallow Copy

01:37:16.520 --> 01:37:18.640
ist halt eine, die nur, die, äh,

01:37:18.720 --> 01:37:19.960
sozusagen, also,

01:37:20.280 --> 01:37:21.940
bei einer, bei einer Liste könnte ich jetzt

01:37:21.940 --> 01:37:23.740
mir sogar vorstellen, dass es oft, wenn ich jetzt nochmal

01:37:23.740 --> 01:37:25.920
Liste drumrum schreibe oder so, dass dann tatsächlich

01:37:25.920 --> 01:37:28.060
eine Kopie erzeugt wird. Also eine nicht-Shallow

01:37:28.060 --> 01:37:30.000
Kopie, aber, äh, wenn ich

01:37:30.000 --> 01:37:32.160
jetzt eine komplizierte Datenstruktur habe

01:37:32.160 --> 01:37:34.080
in irgendeinem Dikt oder so, wo, äh,

01:37:34.120 --> 01:37:36.020
viele Sachen ineinander verschachtelt drin liegen,

01:37:36.400 --> 01:37:37.680
dann ist es so, wenn ich jetzt sage, Dikt

01:37:37.680 --> 01:37:39.720
von dem Ding, dann ist es eine,

01:37:39.960 --> 01:37:42.020
oder wenn ich sage, Copy, dann ist das

01:37:42.020 --> 01:37:43.960
eine Shallow Kopie. Und, ähm,

01:37:45.440 --> 01:37:45.720
äh,

01:37:45.940 --> 01:37:47.640
sozusagen... Warum brauche ich dann überhaupt eine Shallow Kopie?

01:37:47.640 --> 01:37:49.260
Dann könnte ich auch einfach auf das normale Dikt zeigen, wenn es

01:37:49.260 --> 01:37:50.700
eh nur auf das gleiche Objekt zeigt. Also...

01:37:50.700 --> 01:37:51.360
Ja, ja, ja, genau.

01:37:51.600 --> 01:37:51.960
Genau.

01:37:53.740 --> 01:37:55.420
Wenn ich die Inhalte mitkopieren will, oder,

01:37:55.640 --> 01:37:57.480
äh, dann

01:37:57.480 --> 01:38:00.320
muss, mache ich, gibt es zum Beispiel, ähm,

01:38:01.180 --> 01:38:02.280
äh, eine Funktion

01:38:02.280 --> 01:38:04.460
aus dem Copy, ich glaube, das ist Standard, ja, Standardbibliothek,

01:38:04.780 --> 01:38:06.480
dann sagt man immer, Form Copy, Import Deep Copy,

01:38:06.860 --> 01:38:07.760
und dann sagt man, Deep Copy,

01:38:08.500 --> 01:38:10.080
irgendwie komplizierte Dikt, äh,

01:38:10.100 --> 01:38:11.200
verschachtelte Datenstruktur,

01:38:11.880 --> 01:38:14.100
und die geht dann rekursiv da durch und kopiert

01:38:14.100 --> 01:38:15.800
den ganzen Kram da raus in eine andere Datenstruktur.

01:38:16.080 --> 01:38:18.240
Und dann habe ich halt das tatsächlich getrennt voneinander.

01:38:18.700 --> 01:38:20.100
Aber ansonsten ist das halt, äh,

01:38:20.100 --> 01:38:22.100
nicht so einfach, ja, wenn ich da, äh,

01:38:22.920 --> 01:38:23.600
Dikt, äh,

01:38:23.740 --> 01:38:26.080
drumherum mache, dann kann es zwar auch sein, dass das ein neues

01:38:26.080 --> 01:38:27.400
Dikt ist an einer anderen Speicheradresse,

01:38:27.880 --> 01:38:30.340
und dass die, äh, dass ich die Keys und Values, äh,

01:38:30.360 --> 01:38:32.340
kopiert habe, aber die Values waren halt Referenzen

01:38:32.340 --> 01:38:34.060
auf irgendwas, und die Objekte hinter diesen

01:38:34.060 --> 01:38:35.940
Referenzen haben sich halt nicht geändert, ne, so, und das

01:38:35.940 --> 01:38:38.200
kann halt sehr... Da kann man sich so ein bisschen mit in den Fuß schießen,

01:38:38.280 --> 01:38:40.020
wenn man sowas übergibt wie leere Listen

01:38:40.020 --> 01:38:41.900
als Standardwert vom Keyword. Ja, ja,

01:38:41.920 --> 01:38:43.900
da kann man sich, kann man sich böse in den Fuß schießen mit.

01:38:43.980 --> 01:38:45.440
Weil dann, also das ist, glaube ich, ähm,

01:38:45.820 --> 01:38:47.740
generell das Problem, also bei so ein paar Sachen, die man

01:38:47.740 --> 01:38:49.860
als Keyword setzt, ja, wenn man das irgendwie in eine Funktion hat,

01:38:49.860 --> 01:38:51.800
da wird ein Keyword übergeben, das setzt man

01:38:51.800 --> 01:38:53.920
einem Default-Wert, indem es zum Beispiel eine leere

01:38:53.920 --> 01:38:55.360
Liste hat, oder einen, einen random

01:38:55.360 --> 01:38:57.620
initialisierten Wert, oder sowas, ähm,

01:38:57.740 --> 01:38:59.800
der wird halt beim ersten Mal dann initialisiert, und da steht

01:38:59.800 --> 01:39:01.900
dann halt aber eine Speicheradresse dieser Wert drin, der dann

01:39:01.900 --> 01:39:03.820
halt dem zugewiesen ist schon, weil das halt

01:39:03.820 --> 01:39:05.920
dann nur darauf zeigt, und halt nicht jedes Mal ein neues Objekt

01:39:05.920 --> 01:39:07.980
äh, generiert, und das heißt, man hat immer dieselbe

01:39:07.980 --> 01:39:09.880
leere Liste, die dann vielleicht nicht mehr

01:39:09.880 --> 01:39:12.000
leer ist, nachdem man die Funktion einmal aufgerufen hat, und dann,

01:39:12.260 --> 01:39:13.720
ähm, und dann ist es immer die gleiche,

01:39:13.780 --> 01:39:15.880
und dann funktioniert es sogar oft, und dann irgendwann

01:39:15.880 --> 01:39:17.760
fällt es einem ganz furchtbar auf den Fuß, und man

01:39:17.760 --> 01:39:19.600
weiß nicht genau, ja, also das, da, in solchen

01:39:19.600 --> 01:39:21.600
Problemen habe ich auch schon lange rumgedebugt,

01:39:21.620 --> 01:39:23.580
bis ich mir dann so, oh nein, das ist immer die gleiche Liste,

01:39:23.720 --> 01:39:25.860
oh scheiße, und da, da ist

01:39:25.860 --> 01:39:27.780
auch da, äh, Konvention, dass man

01:39:27.780 --> 01:39:29.780
das eben eigentlich, dass man nicht in, als

01:39:29.780 --> 01:39:31.880
Default-Argument, ähm, in eine, in eine

01:39:31.880 --> 01:39:33.420
Funktion reinschreibt, äh, irgendwie

01:39:33.420 --> 01:39:36.020
Default

01:39:36.020 --> 01:39:37.700
gleich, Klammer auf, Klammer zu,

01:39:37.820 --> 01:39:40.080
oder so, hält. Man sagt immer None, und dann

01:39:40.080 --> 01:39:41.600
macht man eine Überprüfung, ob es None ist,

01:39:41.700 --> 01:39:43.780
und dann setzt man die Liste neu. Das ist halt echt

01:39:43.780 --> 01:39:45.700
nur eine böse Fußengel, ja, also das ist,

01:39:45.900 --> 01:39:47.920
das kann, das kann einen schwer

01:39:47.920 --> 01:39:49.580
erwischen. Äh. Ja, bei

01:39:49.580 --> 01:39:51.740
Random werden übrigens genau dasselbe, also wenn ihr jetzt irgendwo

01:39:51.740 --> 01:39:53.360
so ein Zufallswert generieren lassen wollt, wie

01:39:53.360 --> 01:39:55.640
von RandomRandom 1 bis 10 oder sowas,

01:39:55.720 --> 01:39:57.740
und dann habt ihr ihn einmal initialisiert, der gibt nicht jedes Mal,

01:39:57.780 --> 01:39:59.720
wenn ihr die Funktion aufruft, einen Default-Neuen-Zufallswert

01:39:59.720 --> 01:40:01.860
zurück, sondern immer dasselbe. Also das ist,

01:40:02.120 --> 01:40:03.620
äh, ja, an der Stelle, nicht

01:40:03.620 --> 01:40:05.600
intuitiv, also das fand ich auch sehr komisch, dass

01:40:05.600 --> 01:40:07.920
er dann nicht einfach jedes Mal beim Aufrufen das neu initialisiert,

01:40:08.020 --> 01:40:09.600
sondern dass er halt dann die Objekte nimmt, die er einmal

01:40:09.600 --> 01:40:11.280
schon irgendwo liegen hat, ja.

01:40:12.420 --> 01:40:13.600
Ja, äh, also

01:40:13.600 --> 01:40:15.520
wie man, also eine Geschichte, wie man,

01:40:16.260 --> 01:40:17.680
also List-Comprehension macht immer eine Kopie,

01:40:17.780 --> 01:40:19.480
ne, wenn man zum Beispiel erzeugt immer eine neue

01:40:19.480 --> 01:40:21.460
Liste, ansonsten,

01:40:21.760 --> 01:40:23.900
ja, die Kopie aus dem Hobby-Modul, wenn es kompliziertere

01:40:23.900 --> 01:40:25.500
Datenstrukturen sind, dann muss man sich das nicht selber,

01:40:25.680 --> 01:40:27.520
so oft ist es ja, ich meine, es ist ja wirklich kompliziert, wenn man

01:40:27.520 --> 01:40:29.220
da halt, äh, was, äh,

01:40:30.160 --> 01:40:31.760
ja, man muss halt rekursiv durchgehen

01:40:31.760 --> 01:40:33.540
und das will man ja vielleicht auch nicht selber schreiben, da gibt's halt

01:40:33.540 --> 01:40:35.640
schon ein Ding für, ähm, was man da benutzen

01:40:35.640 --> 01:40:37.340
kann. Dann, dann ist es so,

01:40:37.500 --> 01:40:39.480
naja, was, was diese unterschiedlichen Stile angeht,

01:40:39.640 --> 01:40:40.700
also, ähm,

01:40:41.740 --> 01:40:43.600
wenn man sich so ein bisschen anguckt, was in den,

01:40:43.840 --> 01:40:45.520
äh, es gibt ja unterschiedliche Arten

01:40:45.520 --> 01:40:47.520
zu programmieren, ja, so imperativ,

01:40:47.680 --> 01:40:49.240
ich würde auch Python eher, auch wenn,

01:40:49.480 --> 01:40:51.580
wenn man auch mit Berechtigung sagen kann, es ist auch irgendwie eine

01:40:51.580 --> 01:40:53.420
funktionale Programmiersprache,

01:40:53.700 --> 01:40:55.580
ähm, ist es doch eher, die meisten

01:40:55.580 --> 01:40:57.140
Leute verwenden es halt irgendwie imperativ

01:40:57.140 --> 01:41:00.180
und, ähm,

01:41:00.340 --> 01:41:01.700
in, in dem, ja,

01:41:01.820 --> 01:41:03.500
Lager sozusagen, Paradigma

01:41:03.500 --> 01:41:05.240
der funktionalen Programmiersprachen ist es aber eher so, dass

01:41:05.240 --> 01:41:07.580
man halt da, äh, und, und nicht

01:41:07.580 --> 01:41:09.580
nur da, das setzt sich auch in anderen Bereichen durch,

01:41:09.720 --> 01:41:11.360
in JavaScript sehen wir das in letzter Zeit oft,

01:41:12.020 --> 01:41:13.780
äh, auch wenn es um so State-Handling

01:41:13.780 --> 01:41:15.820
Geschichten geht, da gibt's dann Redux,

01:41:16.020 --> 01:41:17.660
ähm, und so,

01:41:18.180 --> 01:41:18.920
äh, ähm,

01:41:19.480 --> 01:41:22.020
dass, dass man, wenn man, wenn man jetzt, ähm,

01:41:23.100 --> 01:41:23.820
solche, solche Sachen

01:41:23.820 --> 01:41:25.960
handelt, äh, versucht immer

01:41:25.960 --> 01:41:27.820
nur mit, äh, Datenstrukturen

01:41:27.820 --> 01:41:29.480
zu arbeiten, die nicht veränderbar sind,

01:41:29.760 --> 01:41:31.140
also die mutable sind

01:41:31.140 --> 01:41:33.820
und immer nur Kopien erzeugt, wenn man

01:41:33.820 --> 01:41:35.580
irgendwas ändert, also man ändert nichts

01:41:35.580 --> 01:41:37.400
in einer bestimmten Datenstruktur, sondern man,

01:41:37.580 --> 01:41:39.980
ähm, erzeugt

01:41:39.980 --> 01:41:41.940
eine neue Kopie und, ähm,

01:41:43.520 --> 01:41:44.040
äh, an der

01:41:44.040 --> 01:41:45.860
ändert man dann halt irgendwas, beziehungsweise

01:41:45.860 --> 01:41:47.960
man ändert nix, sondern man baut es dann halt

01:41:47.960 --> 01:41:49.460
neu. Ähm,

01:41:49.480 --> 01:41:51.740
ähm, was halt

01:41:51.740 --> 01:41:53.460
diverse, sehr, sehr, äh, sehr, sehr coole

01:41:53.460 --> 01:41:55.740
Nebeneffekte hat, unter anderem, dass ich Sachen dann

01:41:55.740 --> 01:41:56.960
perfekt parallelisieren kann,

01:41:57.980 --> 01:41:59.720
äh, dass ich weiß, dass ich keine

01:41:59.720 --> 01:42:01.700
Seiteneffekte habe, dass ich, äh,

01:42:02.060 --> 01:42:03.280
super testen kann, äh,

01:42:03.340 --> 01:42:05.640
das, das, na, es, ähm,

01:42:05.800 --> 01:42:07.800
es hat, es hat eine Menge, und immer wenn,

01:42:07.840 --> 01:42:09.760
wenn Leute, die aus so einer funktionalen Ecke kommen,

01:42:10.340 --> 01:42:11.760
sehen, was man so in Python imperativ

01:42:11.760 --> 01:42:13.720
macht, dass man irgendwie, äh, Attribute

01:42:13.720 --> 01:42:15.080
von irgendwelchen Objekten ändert oder halt

01:42:15.080 --> 01:42:17.360
irgendwie ein Dikt übergeben bekommt, dass man irgendwie

01:42:17.360 --> 01:42:19.300
in, dann ändert, oder, äh,

01:42:19.300 --> 01:42:19.420
äh,

01:42:19.480 --> 01:42:21.880
äh, also würde man jetzt

01:42:21.880 --> 01:42:23.260
in funktionaler, äh, in einer

01:42:23.260 --> 01:42:25.220
richtigen, Entschuldigung,

01:42:25.280 --> 01:42:27.480
in einer richtigen, funktionalen Programmiersprache würde man nie

01:42:27.480 --> 01:42:29.800
irgendwie einen Dikt oder eine Liste

01:42:29.800 --> 01:42:31.380
oder sowas in der Funktion nehmen,

01:42:31.700 --> 01:42:33.520
da irgendwas dran ändern und das Ding dann wieder zurückgeben

01:42:33.520 --> 01:42:35.360
oder so, oder am besten gar nicht zurückgeben, sondern

01:42:35.360 --> 01:42:37.460
einfach nur ändern, sondern man würde

01:42:37.460 --> 01:42:39.300
immer, wenn man was ändert, eine neue Kopie

01:42:39.300 --> 01:42:39.740
zurückgeben,

01:42:41.120 --> 01:42:43.020
weil man dann halt diesen ganzen schönen Effekt hat,

01:42:43.400 --> 01:42:44.740
was, wenn man das nicht tut,

01:42:45.400 --> 01:42:47.620
was, würde ich sagen, aber in Python oft so ist,

01:42:47.760 --> 01:42:48.880
äh, also man,

01:42:48.880 --> 01:42:50.900
man übergibt irgendwo eine Liste

01:42:50.900 --> 01:42:53.040
und dann ändert man irgendwie ein Element in dieser Liste

01:42:53.040 --> 01:42:54.080
und dann gibt man die Liste wieder zurück,

01:42:55.240 --> 01:42:57.040
dann gehen ganz viele schöne Sachen nicht mehr,

01:42:57.140 --> 01:42:59.020
weil dann, äh, ist es halt, äh, ja.

01:43:00.580 --> 01:43:02.620
Das hat vielleicht irgendwas kaputt gemacht.

01:43:03.060 --> 01:43:04.980
Ja. Was auf der anderen Seite

01:43:04.980 --> 01:43:06.940
manchmal halt auch cool total viel einfacher macht,

01:43:07.020 --> 01:43:09.000
als wenn jetzt in, wenn man es funktional schreibt,

01:43:09.120 --> 01:43:11.020
dann, und auch effizienter, weil

01:43:11.020 --> 01:43:12.860
also einmal ist es so, man kann halt Dinge

01:43:12.860 --> 01:43:14.220
nicht mehr so richtig direkt beeinflussen

01:43:14.220 --> 01:43:16.860
und, äh, ist es halt so, man muss halt, wenn man

01:43:16.860 --> 01:43:18.580
alles immer kopiert und jetzt man,

01:43:18.880 --> 01:43:20.220
weil jetzt große Datenmengen hat zum Beispiel,

01:43:20.340 --> 01:43:22.800
im Data-Science-Bereich ist es halt, wenn da deine Datenstrukturen

01:43:22.800 --> 01:43:24.800
alle hunderte Megabyte groß sind und du machst immer

01:43:24.800 --> 01:43:26.640
Kopien von allem, was auch,

01:43:27.040 --> 01:43:29.200
also tatsächlich, Pandas macht das auch per Default,

01:43:29.300 --> 01:43:30.940
wenn irgendwelche, alle Operationen

01:43:30.940 --> 01:43:31.860
geben immer Kopien zurück,

01:43:32.980 --> 01:43:34.980
aber das kann auch ganz schön in den Hauptspeicher gehen

01:43:34.980 --> 01:43:36.920
oder manchmal muss man dann schon sagen so, ja, hier bitte

01:43:36.920 --> 01:43:38.840
nicht kopieren, das geht einfach nicht, passt dann nicht mehr

01:43:38.840 --> 01:43:40.980
und dann, äh, muss man

01:43:40.980 --> 01:43:42.800
halt, äh, Sachen

01:43:42.800 --> 01:43:45.020
direkt, äh, in place, äh, ändern

01:43:45.020 --> 01:43:46.940
oder so und das ist natürlich immer ein bisschen schmutzig, aber

01:43:46.940 --> 01:43:47.500
ja.

01:43:48.880 --> 01:43:49.500
Ja, ja.

01:43:50.380 --> 01:43:51.580
Dunkle Magie, wieder.

01:43:52.980 --> 01:43:54.380
Ja, also hängt davon ab, würde ich sagen,

01:43:54.420 --> 01:43:56.200
was man für ein Problem hat und, äh,

01:43:56.400 --> 01:43:58.580
also wenn man das nicht kennt, dann sich mal so anzugucken,

01:43:58.660 --> 01:44:00.520
wie man mit alten Datenstrukturen einfach

01:44:00.520 --> 01:44:02.460
nur Immutable irgendwie hält und immer

01:44:02.460 --> 01:44:04.660
Kopien zurück, das ist eigentlich schon diese, die, die, das ist schon sehr schick,

01:44:04.780 --> 01:44:06.360
aber. Also, dann kommen wir direkt,

01:44:06.460 --> 01:44:08.680
schließ direkt an, was ist denn deine Lieblingsdatenstruktur?

01:44:09.940 --> 01:44:10.840
Meine Lieblingsdatenstruktur,

01:44:10.920 --> 01:44:12.360
also ich, tatsächlich, ja,

01:44:12.520 --> 01:44:12.680
Dict.

01:44:14.340 --> 01:44:16.300
Hätte ich jetzt auch gesagt, früher fand ich Dict ein ganz toller Dict, aber

01:44:16.300 --> 01:44:18.800
ich auch, also vielleicht müssen wir mal

01:44:18.800 --> 01:44:19.240
gerade, ist ja.

01:44:19.600 --> 01:44:22.300
Naja, also, und vor allen Dingen ist die, die Dict-Inflamentation

01:44:22.300 --> 01:44:23.840
in Python ist halt auch total super.

01:44:24.200 --> 01:44:25.040
Also, die ist richtig schnell,

01:44:26.040 --> 01:44:28.580
äh, die, die ist, ja, ja, ist halt sehr effizientes

01:44:28.580 --> 01:44:30.500
Ding und ein Riesenhaufen

01:44:30.500 --> 01:44:32.440
Probleme lassen sich dadurch schon lösen, ja, also

01:44:32.440 --> 01:44:34.440
wenn man das ordentlich verwendet, dann kriegt

01:44:34.440 --> 01:44:36.640
man da so einen sehr großen

01:44:36.640 --> 01:44:38.780
Teil der so 0815-Programmiergeschichten,

01:44:38.860 --> 01:44:40.460
die man so macht, kriegt man halt mit Listen und Dicts

01:44:40.460 --> 01:44:42.040
irgendwie abgebildet. Ähm,

01:44:43.060 --> 01:44:44.560
Listen braucht man auch, äh, halt gerade,

01:44:44.640 --> 01:44:46.360
wenn man irgendwelche Dinge iteriert und so,

01:44:46.480 --> 01:44:48.080
aber, äh, Dicts ist halt

01:44:48.080 --> 01:44:48.780
das schöne,

01:44:48.800 --> 01:44:50.100
das Schlimme daran ist, dass man halt irgendwie sozusagen

01:44:50.100 --> 01:44:52.900
beliebige Dinge irgendwie speichern kann, ja, und, äh,

01:44:53.100 --> 01:44:53.600
man kann die

01:44:53.600 --> 01:44:56.780
Namen, unter denen man das findet,

01:44:56.880 --> 01:44:58.780
dann halt irgendwie dynamisch generieren und, äh,

01:44:58.780 --> 01:45:00.340
muss das halt nicht vorher definiert haben in Code.

01:45:00.700 --> 01:45:01.940
Mhm. Ja.

01:45:03.160 --> 01:45:04.660
Und, äh, wann nutzt man denn Tupel,

01:45:04.720 --> 01:45:06.660
das Plattenstruktur, wenn man eine Listen hat? Also, warum ist das

01:45:06.660 --> 01:45:08.560
überhaupt? Ja, Tupel sind, ähm,

01:45:08.880 --> 01:45:10.480
sind halt immutable, ja, genau.

01:45:11.000 --> 01:45:12.640
Äh, das ist halt der Grund, deswegen

01:45:12.640 --> 01:45:14.960
an den Stellen,

01:45:15.000 --> 01:45:16.800
wo man's halt immutable haben will, dann kann man,

01:45:16.800 --> 01:45:17.780
kann man die halt gut nehmen.

01:45:18.800 --> 01:45:20.900
Zum Beispiel, wenn du halt möchtest, dass etwas

01:45:20.900 --> 01:45:22.840
Dict, äh, Key in einem Dict sein kann, ne,

01:45:22.840 --> 01:45:23.820
das geht halt mit einer Liste nicht.

01:45:24.680 --> 01:45:25.760
Da musst du halt einen Tupel nehmen.

01:45:27.300 --> 01:45:28.880
Ähm, oder

01:45:28.880 --> 01:45:30.700
halt bei so Geschichten wie Tupel,

01:45:30.800 --> 01:45:32.860
Unpacking und so, da, das geht auch nur

01:45:32.860 --> 01:45:34.820
mit, äh, doch, das geht auch mit Listen.

01:45:35.460 --> 01:45:37.020
Klar, das geht auch mit Listen, aber

01:45:37.020 --> 01:45:38.800
ich weiß, ich überlege jetzt gerade, ob es einen tieferen Grund

01:45:38.800 --> 01:45:40.680
gibt, warum Argumente

01:45:40.680 --> 01:45:42.220
Tupel sind.

01:45:44.300 --> 01:45:44.620
Also,

01:45:44.980 --> 01:45:45.900
ja,

01:45:47.900 --> 01:45:48.300
generell,

01:45:48.300 --> 01:45:50.180
also, Dict Key war vielleicht eine gute Idee,

01:45:50.320 --> 01:45:50.500
ja.

01:45:51.540 --> 01:45:54.000
Es gibt schon den Fall

01:45:54.000 --> 01:45:56.240
öfter mal, dass man das halt nicht änderbar haben will

01:45:56.240 --> 01:45:58.440
und dann nimmt man halt einen Tupel statt eine Liste.

01:45:59.160 --> 01:46:00.140
Aber tatsächlich ist es so,

01:46:00.400 --> 01:46:01.280
es gibt auch, äh, also,

01:46:01.800 --> 01:46:03.780
eskalare sozusagen einfache Werte,

01:46:04.040 --> 01:46:05.560
irgendwie, also sowas wie eine 5 oder

01:46:05.560 --> 01:46:07.200
äh,

01:46:07.980 --> 01:46:10.100
String, wobei man's, äh,

01:46:10.100 --> 01:46:11.580
äh,

01:46:11.620 --> 01:46:14.080
Listen und Dicts ist halt auch so das, dass man in allen

01:46:14.080 --> 01:46:15.860
Programmiersprachen irgendwie oder allen, vor allen Dingen

01:46:15.860 --> 01:46:17.860
in allen Skriptsprachen irgendwie eingebaut findet, ja,

01:46:17.860 --> 01:46:19.960
dass das halt auch in Perl und in PHP und in

01:46:19.960 --> 01:46:21.840
JavaScript, die heißen halt

01:46:21.840 --> 01:46:23.940
in allen, äh, diesen Programmiersprachen irgendwie

01:46:23.940 --> 01:46:25.700
ein bisschen anders, ne, in Perl heißt es halt

01:46:25.700 --> 01:46:27.920
Hash und, äh, Array, ja,

01:46:28.020 --> 01:46:29.480
in PHP heißt es, äh,

01:46:30.340 --> 01:46:31.960
Assoziatives Array, äh,

01:46:32.620 --> 01:46:33.920
und, äh,

01:46:34.180 --> 01:46:35.360
weiß ich nicht, ähm,

01:46:35.540 --> 01:46:37.860
JavaScript heißt es halt Object und, äh,

01:46:38.840 --> 01:46:39.960
äh, ich glaub, da heißt es aber dann

01:46:39.960 --> 01:46:41.720
auch Array, ja, naja.

01:46:42.240 --> 01:46:43.160
Aber, äh,

01:46:43.440 --> 01:46:45.800
diese Grunddatentypen hast du halt überall, deswegen

01:46:45.800 --> 01:46:47.820
war das halt, das, damit kannst du halt schon eine Menge

01:46:47.820 --> 01:46:49.660
machen und Tupple gibt's halt

01:46:49.660 --> 01:46:51.180
eigentlich, glaub ich, nur in Python

01:46:51.180 --> 01:46:53.860
und anderswo nicht, weil es auch sonst nicht so

01:46:53.860 --> 01:46:54.740
häufig reinet wird.

01:46:55.700 --> 01:46:57.640
Ähm, ist halt schon eher so ein bisschen Spezialfall.

01:46:58.580 --> 01:46:58.740
Ja.

01:47:00.340 --> 01:47:01.800
Ja, es gibt auch oft von

01:47:01.800 --> 01:47:02.660
den ganzen,

01:47:04.580 --> 01:47:05.740
äh,

01:47:05.860 --> 01:47:07.500
also was auch mittlerweile, glaub ich, ein integrierter

01:47:07.500 --> 01:47:09.380
Datentyp ist, ist halt Z in Python.

01:47:10.120 --> 01:47:11.540
Ja. Das ist auch, äh,

01:47:12.060 --> 01:47:13.500
eine Datenstruktur, die wir relativ häufig, oder

01:47:13.500 --> 01:47:15.640
ich benutze die relativ häufig und

01:47:15.640 --> 01:47:17.640
von denen gibt's halt dann auch Immutable-Varianten,

01:47:17.820 --> 01:47:19.440
weiß jetzt gar nicht, ob's Immutable-Tickets gibt,

01:47:20.580 --> 01:47:21.660
äh, aber zum Beispiel von

01:47:21.660 --> 01:47:23.640
Z gibt's halt Frozen-Z, eben auch für solche

01:47:23.640 --> 01:47:25.740
Fälle, wie du möchtest, dass das irgendwie, äh,

01:47:25.740 --> 01:47:27.000
das Key in Dict ist oder so.

01:47:28.020 --> 01:47:29.660
Und, äh, den kannst du halt dann nicht mehr

01:47:29.660 --> 01:47:31.120
verändern. Ja.

01:47:31.460 --> 01:47:33.440
Vielleicht gibt's auch sowas wie eine Frozen-List, ich weiß nicht genau.

01:47:34.800 --> 01:47:35.960
Ja. Aber Frozen-Z

01:47:35.960 --> 01:47:37.560
benutze ich tatsächlich ab und zu. Frozen-List ist

01:47:37.560 --> 01:47:39.300
Tupple? Ja, könnte sein, genau.

01:47:39.460 --> 01:47:40.660
Frozen-List ist Tupple, ja, genau.

01:47:41.140 --> 01:47:41.680
Ja, ja.

01:47:43.540 --> 01:47:45.400
Ähm, okay. Wann muss man denn

01:47:45.400 --> 01:47:47.560
Numpy erase? Ja, immer

01:47:47.560 --> 01:47:49.000
dann, wenn man halt, äh,

01:47:49.380 --> 01:47:50.240
sozusagen,

01:47:52.240 --> 01:47:52.980
äh,

01:47:53.520 --> 01:47:55.420
so viele Daten hat, dass es, äh, irgendwie

01:47:55.420 --> 01:47:57.000
nervtöten wird ansonsten.

01:47:57.660 --> 01:47:59.500
Und, äh, wenn man

01:47:59.500 --> 01:48:01.260
jetzt die ganzen Spezialfunktionen vielleicht verwenden

01:48:01.260 --> 01:48:03.420
will, die halt auch in Numpy und so mit drin sind,

01:48:03.540 --> 01:48:05.220
äh, ja,

01:48:05.380 --> 01:48:07.400
und, ähm, genau, dann gehen halt die Sachen,

01:48:07.540 --> 01:48:09.360
die sonst lange dauern, halt einfach

01:48:09.360 --> 01:48:11.520
schnell und sind, muss halt ein bisschen

01:48:11.520 --> 01:48:13.320
anders programmieren, äh, ist halt dann

01:48:13.320 --> 01:48:15.200
alles drauf ausgelegt, dass das, äh,

01:48:15.600 --> 01:48:17.120
vektorisiert wird und, ähm,

01:48:17.120 --> 01:48:19.220
das heißt, vorschleifen und sowas gehen eigentlich nicht mehr.

01:48:19.480 --> 01:48:21.080
Und was natürlich ein bisschen sehr anders ist

01:48:21.080 --> 01:48:22.100
als das, was man normalerweise macht.

01:48:22.900 --> 01:48:24.880
Aber, ja. Okay.

01:48:25.740 --> 01:48:26.980
Dafür braucht man dann bei Numpy erase,

01:48:27.040 --> 01:48:28.440
muss man dann mit Lambda's arbeiten oder, äh,

01:48:28.440 --> 01:48:31.080
ja, oder halt die Funktionen verwenden, die es schon

01:48:31.080 --> 01:48:33.040
gibt. Das meiste gibt's ja, sozusagen, würde ich mal

01:48:33.040 --> 01:48:35.060
sagen. Und dann ansonsten, wenn's das halt nicht gibt, dann

01:48:35.060 --> 01:48:36.280
genau, übergibt man halt eine Funktion.

01:48:37.300 --> 01:48:39.000
Ah. Okay.

01:48:39.080 --> 01:48:40.780
Wie sehr realisiert siehst du denn denn Daten für

01:48:40.780 --> 01:48:42.440
Übertragungen? Hm.

01:48:43.520 --> 01:48:43.820
Ja.

01:48:43.820 --> 01:48:43.900
Ähm.

01:48:46.320 --> 01:48:46.960
Kommt drauf an.

01:48:47.500 --> 01:48:49.560
Also, erstmal, was das überhaupt realisieren ist, halt,

01:48:49.660 --> 01:48:51.980
in Zeichenkette umwandeln, dass man das irgendwo hinschicken kann

01:48:51.980 --> 01:48:53.920
und dass, wenn man dann weiß, was dahintersteckt,

01:48:53.960 --> 01:48:55.760
dann man daraus wieder Objekte baut, mit denen man

01:48:55.760 --> 01:48:57.940
Dinge tut. Ja, äh, oder, genau,

01:48:58.040 --> 01:48:59.840
ich würde sagen, man hat eine Datenstruktur und man möchte

01:48:59.840 --> 01:49:01.720
sie halt in irgendeine Form

01:49:01.720 --> 01:49:03.860
so, äh, verwandeln, dass man

01:49:03.860 --> 01:49:05.620
sie halt irgendwie über Netzwerke verschicken kann oder

01:49:05.620 --> 01:49:07.860
irgendwo hinspeichern kann und man setzt sie hinterher

01:49:07.860 --> 01:49:09.740
irgendwo wieder. Aufschreiben kann auf Papier, dann kann man sie abschreiben.

01:49:10.160 --> 01:49:12.160
Genau, abschreiben. Und, äh,

01:49:12.160 --> 01:49:13.560
hat die gleiche Datenstruktur wieder.

01:49:14.240 --> 01:49:16.280
Äh, irgendwie. Äh, und das

01:49:16.280 --> 01:49:16.960
kann man natürlich,

01:49:17.120 --> 01:49:19.440
nachdem, wie kompliziert das ist, was man halt, äh,

01:49:20.880 --> 01:49:21.800
ein- und auspacken

01:49:21.800 --> 01:49:23.460
möchte, beliebig kompliziert gestalten.

01:49:24.200 --> 01:49:24.640
Ähm,

01:49:25.660 --> 01:49:27.420
also das, was heutzutage ganz oft

01:49:27.420 --> 01:49:29.120
verwendet wird und insofern ist auch

01:49:29.120 --> 01:49:31.280
keine so schlechte Wahl. Jason wird

01:49:31.280 --> 01:49:32.940
halt oft benutzt.

01:49:33.080 --> 01:49:35.120
Kannst halt dann einfach uns auch, ja,

01:49:35.660 --> 01:49:36.920
einfach nach Jason verwandeln.

01:49:37.040 --> 01:49:39.000
Also alles, was irgendwie so Richtung Dict ist oder verschachtelt

01:49:39.000 --> 01:49:40.520
Dicts und, also was,

01:49:40.520 --> 01:49:41.940
wie meistens hast du irgendwie

01:49:41.940 --> 01:49:44.400
Listen und Dicts irgendwie ineinander verschachtelt,

01:49:44.500 --> 01:49:46.720
sozusagen als Datenstruktur. Und das kannst du halt hervorragend

01:49:46.720 --> 01:49:47.100
irgendwie als,

01:49:47.120 --> 01:49:48.460
als Jason einfach. Also auch mit

01:49:48.460 --> 01:49:50.740
kein Problem, auch mit Tucheln kein Problem.

01:49:51.480 --> 01:49:52.960
Ähm, Daten, also

01:49:52.960 --> 01:49:55.440
Datums. Genau, das ist

01:49:55.440 --> 01:49:57.120
Datumsformate, das ist halt

01:49:57.120 --> 01:49:59.080
blöd. Genau, solche Sachen gehen dann schon nicht mehr

01:49:59.080 --> 01:50:00.880
so gut, ne? Also, wenn du jetzt ein

01:50:00.880 --> 01:50:03.140
Datum hast, dass du irgendwie, oder ein Zeitstemp,

01:50:03.200 --> 01:50:05.180
äh, irgendwie einen Zeitpunkt, wenn du den irgendwie

01:50:05.180 --> 01:50:07.140
in Jason, äh, speichern

01:50:07.140 --> 01:50:08.820
willst, dann ist halt blöd. Also der, der

01:50:08.820 --> 01:50:10.820
Vorgang von Datum ist Daten, ne? Das ist aber gerade

01:50:10.820 --> 01:50:12.820
ein bisschen verwirrend, wenn wir über Daten schon so reden.

01:50:13.100 --> 01:50:14.780
Aber ja. Ja, genau.

01:50:14.780 --> 01:50:16.160
Das ist, das ist ein bisschen kacke.

01:50:17.120 --> 01:50:18.720
Ähm, und dann gibt's natürlich dann

01:50:18.720 --> 01:50:20.580
diverse ISO-Standards, wie man das dann doch

01:50:20.580 --> 01:50:22.720
irgendwie mit Zeitzone und keine Ahnung.

01:50:22.820 --> 01:50:24.480
Und dann bist du aber darauf angewiesen, dass alle irgendwie

01:50:24.480 --> 01:50:26.740
die gleiche Idee davon haben, was denn jetzt in diesem

01:50:26.740 --> 01:50:28.860
Spring, der da in dem Jason

01:50:28.860 --> 01:50:30.740
steht, ähm, was das denn, was

01:50:30.740 --> 01:50:32.840
in der Limit jetzt gemeint ist. Und das ist manchmal ein bisschen,

01:50:32.940 --> 01:50:33.960
bisschen nervtötend.

01:50:34.660 --> 01:50:36.280
Ähm, aber, äh,

01:50:36.760 --> 01:50:38.780
solange man nicht, also Datum ist immer etwas, was

01:50:38.780 --> 01:50:40.760
meistens dann Probleme macht. Aber einfach

01:50:40.760 --> 01:50:42.800
so Listen, äh,

01:50:42.920 --> 01:50:44.500
Dicts, äh, Strings,

01:50:44.500 --> 01:50:45.560
das funktioniert ganz gut.

01:50:46.720 --> 01:50:47.060
Und, ähm,

01:50:47.120 --> 01:50:49.180
ja, also für diese einfachen Fälle

01:50:49.180 --> 01:50:51.240
ist Jason ganz gut geeignet.

01:50:52.080 --> 01:50:53.220
Äh, da da auch mittlerweile

01:50:53.220 --> 01:50:55.220
so viel verwendet wird, ist da auch viel Arbeit reingeflossen,

01:50:55.320 --> 01:50:57.120
wie Parser und, äh,

01:50:58.500 --> 01:50:59.300
ähm, äh,

01:50:59.460 --> 01:51:01.140
Rausschreibdinger halt so schnell

01:51:01.140 --> 01:51:02.980
zu machen. Und das geht eigentlich alles ziemlich gut.

01:51:04.220 --> 01:51:05.140
Ähm, es ist halt auch

01:51:05.140 --> 01:51:07.040
halbwegs, äh, sparsam, was halt

01:51:07.040 --> 01:51:08.140
sozusagen den Platz angeht.

01:51:08.820 --> 01:51:11.220
Eben sowas wie XML nimmst. XML ist halt da,

01:51:11.360 --> 01:51:12.840
äh, kannst du mehr mitmachen. Aber

01:51:12.840 --> 01:51:15.020
es ist halt komplizierter. Es sind auch, und viele Dinge

01:51:15.020 --> 01:51:17.020
sind da schon gedacht worden. Aber, äh,

01:51:17.120 --> 01:51:18.880
das ist halt einfach, es ist, es wird

01:51:18.880 --> 01:51:19.880
oft riesig.

01:51:20.940 --> 01:51:22.760
Was heißt mehr kann man damit machen? Warum?

01:51:22.880 --> 01:51:25.120
Ja, da kannst du halt, ja, du kannst

01:51:25.120 --> 01:51:26.920
da ja ein Format dann definieren. Du kannst ja halt

01:51:26.920 --> 01:51:28.900
irgendwie, äh, auch definieren, wie

01:51:28.900 --> 01:51:31.060
die Daten aussehen. Du kannst beschreiben,

01:51:31.220 --> 01:51:32.200
wie das, was du,

01:51:32.320 --> 01:51:34.680
sagen wir, reinschreibst, wann das okay ist.

01:51:34.740 --> 01:51:36.800
Du kannst halt eine DTD, äh,

01:51:37.120 --> 01:51:38.800
Data, wie heißt das, Data Type Definition,

01:51:38.860 --> 01:51:40.320
zu deinem XML

01:51:40.320 --> 01:51:42.640
dazuschreiben. Das halt sozusagen definiert, wie

01:51:42.640 --> 01:51:44.800
das Format von deinem XML aussieht.

01:51:45.140 --> 01:51:46.880
Und dann kannst du das validieren dagegen und so.

01:51:47.120 --> 01:51:47.560
Ja.

01:51:48.960 --> 01:51:49.280
Wow.

01:51:52.780 --> 01:51:53.560
Aber, äh.

01:51:53.560 --> 01:51:54.760
Ein heimlicher XML-Fan?

01:51:54.820 --> 01:51:56.080
Nein, nein, nein, nein, nein.

01:51:57.100 --> 01:51:57.760
Los, nicht.

01:51:58.220 --> 01:52:00.640
Nee, das ist alles sehr schrecklich. Also, äh,

01:52:00.800 --> 01:52:03.380
ich meine, man kann das machen, aber das ist alles, äh,

01:52:03.500 --> 01:52:04.800
nee, das, es gibt auch einen Grund, warum das

01:52:04.800 --> 01:52:05.980
quasi niemand, also,

01:52:06.280 --> 01:52:07.680
niemand tut.

01:52:09.380 --> 01:52:10.720
Äh, das ist,

01:52:10.920 --> 01:52:12.940
oh, ja, also,

01:52:13.680 --> 01:52:14.840
in der Anfangszeit war das, äh,

01:52:14.840 --> 01:52:16.820
oder ich, also, mittlerweile ist das

01:52:16.820 --> 01:52:19.020
auch alles nicht mehr so schlimm, das gibt gute Bibliotheken,

01:52:19.140 --> 01:52:20.780
aber, äh,

01:52:21.200 --> 01:52:22.840
äh, es war schon, war schon nicht

01:52:22.840 --> 01:52:24.840
so einfach, äh, manchmal. Und was halt an XML

01:52:24.840 --> 01:52:26.960
nervtötend ist, ist halt, du kannst es als Mensch nicht gut lesen,

01:52:27.340 --> 01:52:28.840
es ist halt gigantisch groß,

01:52:29.080 --> 01:52:30.440
ähm. Hässlich.

01:52:30.740 --> 01:52:32.620
Hässlich, ja. Ähm.

01:52:33.940 --> 01:52:34.300
Ähm.

01:52:35.600 --> 01:52:36.640
Ja, äh,

01:52:36.740 --> 01:52:38.600
und, äh, dann gibt's natürlich noch sowas wie Jammel

01:52:38.600 --> 01:52:40.740
oder so, heute irgendwie so ein bisschen auch

01:52:40.740 --> 01:52:41.960
wieder en vogue, äh.

01:52:42.660 --> 01:52:44.400
Auch hässlich. Ist aber auch, ja,

01:52:44.500 --> 01:52:46.260
ist auch ein bisschen hässlich, muss man leider sagen, ja.

01:52:46.820 --> 01:52:48.660
Äh, also, wie hat das

01:52:48.660 --> 01:52:50.520
mal jemand, äh, von mir, ne, so irgendwie

01:52:50.520 --> 01:52:52.660
Jammel, das, also, das raus, das, was dabei rauskommt,

01:52:52.720 --> 01:52:54.460
wenn man irgendwie alle Fehler

01:52:54.460 --> 01:52:56.420
ignoriert, die bei, bei Jason gemacht worden sind.

01:52:56.480 --> 01:52:58.620
Und Jason ist das, was rauskommt, wenn man alle Fehler ignoriert,

01:52:58.700 --> 01:53:00.400
die bei XML gemacht worden sind.

01:53:01.080 --> 01:53:02.340
Und die, äh,

01:53:02.440 --> 01:53:03.840
Geschichte wiederholt sich immer und immer wieder.

01:53:04.740 --> 01:53:06.560
Irgendwie das nächste Format heißt, was man nicht gebrauchen kann.

01:53:06.920 --> 01:53:08.360
Genau, das ist halt echt so ein, aber

01:53:08.360 --> 01:53:10.240
XML ist auch so ein bisschen, äh, das

01:53:10.240 --> 01:53:12.200
wurde früher immer gespottet, ne, dass man

01:53:12.200 --> 01:53:14.180
dem Format ansieht, dass es irgendwie von Juristen

01:53:14.180 --> 01:53:16.100
und nicht von Informatikern konzipiert wurde.

01:53:16.820 --> 01:53:18.580
Und dass man irgendwie solche Sachen nicht hat, wie,

01:53:18.740 --> 01:53:20.780
also, äh, du kannst es nicht ordentlich quoten.

01:53:21.720 --> 01:53:22.980
Äh, wenn du jetzt zum Beispiel,

01:53:23.060 --> 01:53:24.340
du kannst halt innerhalb von XML,

01:53:24.640 --> 01:53:26.560
gibt's halt sowas wie Kommentare,

01:53:26.720 --> 01:53:29.000
wie willst du XML-Kommentare quoten? Das geht überhaupt gar nicht.

01:53:29.580 --> 01:53:31.240
Und das heißt, wenn du jetzt zum Beispiel, äh,

01:53:31.440 --> 01:53:33.380
in XML, in einem XML-Dokument

01:53:33.380 --> 01:53:34.680
beschreiben willst, wie denn jetzt

01:53:34.680 --> 01:53:36.840
XML auszusehen hat mit XML-Kommentaren,

01:53:37.880 --> 01:53:38.800
dann passieren ganz schreckliche Sachen,

01:53:38.860 --> 01:53:40.040
das geht alles überhaupt gar nicht.

01:53:40.040 --> 01:53:41.200
Und es ist halt so,

01:53:41.540 --> 01:53:43.780
es kann doch nicht sein, dass daran keiner gedacht hat, dass das jetzt nicht,

01:53:43.900 --> 01:53:46.020
das geht einfach nicht. Und, ähm, ja,

01:53:46.160 --> 01:53:46.560
es ist alles,

01:53:46.820 --> 01:53:49.280
es ist nicht so, dass man sich sagt, das ist voll super elegant,

01:53:49.400 --> 01:53:50.800
total gut, äh, nehmen wir jetzt sofort.

01:53:51.240 --> 01:53:53.500
Sondern es ist mehr so, oh, schrecklich.

01:53:54.420 --> 01:53:55.820
Ähm, und JSON ist

01:53:55.820 --> 01:53:57.920
aus dieser Perspektive für mich weniger schrecklich.

01:53:58.080 --> 01:53:59.640
Also, es ist halt, es kann deutlich weniger.

01:54:00.240 --> 01:54:01.720
Aber, äh, okay, äh,

01:54:01.860 --> 01:54:03.260
dafür ist es halt alles nicht so schlimm.

01:54:03.420 --> 01:54:05.480
Ist ja zum Serialisieren da, also, dass man Daten irgendwo hinlegt,

01:54:05.560 --> 01:54:07.080
als, ja, Pfeil oder sowas.

01:54:07.080 --> 01:54:09.220
Aber es gibt natürlich dann gewisse Begrenzungen,

01:54:09.340 --> 01:54:11.260
so was halt dann nicht gut funktioniert.

01:54:11.880 --> 01:54:13.000
Äh, eben, ja, Datum oder alles,

01:54:13.080 --> 01:54:14.680
was irgendwie komplizierter Objekte sind und Code,

01:54:14.740 --> 01:54:15.860
kannst du da auch nicht mit reinpacken.

01:54:16.820 --> 01:54:17.700
Das geht alles nicht.

01:54:18.580 --> 01:54:21.020
Und, äh, auch dann für die Übertragung im Netz

01:54:21.020 --> 01:54:22.520
ist es halt auch teilweise nicht so gut,

01:54:22.600 --> 01:54:24.860
weil das halt dann Text ist und, äh,

01:54:25.160 --> 01:54:26.920
das hat also bestimmte schlechte Eigenschaften.

01:54:27.800 --> 01:54:28.620
Du möchtest eigentlich,

01:54:29.020 --> 01:54:31.080
naja, da gibt es dann sowas, da gibt es ein etwas besseres Format,

01:54:31.180 --> 01:54:32.720
Message Pack nennt sich das, kann man halt,

01:54:32.820 --> 01:54:35.200
ist so ähnlich wie JSON, bloß, äh,

01:54:35.200 --> 01:54:37.760
binär, äh, so, dass das halt, äh,

01:54:37.900 --> 01:54:39.680
irgendwie nicht kaputt gehen kann

01:54:39.680 --> 01:54:41.520
bei der Übertragung oder nicht so leicht kaputt gehen kann

01:54:41.520 --> 01:54:41.920
wie JSON.

01:54:43.040 --> 01:54:44.100
Ja, ähm,

01:54:45.000 --> 01:54:46.800
und, naja, aber,

01:54:46.820 --> 01:54:48.400
aber JSON ist eigentlich schon, würde ich sagen,

01:54:48.460 --> 01:54:50.720
für viele Fälle so das, was man eigentlich haben will.

01:54:51.540 --> 01:54:52.900
Und, ähm, wenn es dann noch viel

01:54:52.900 --> 01:54:54.580
komplizierter wird, kann man auch sowas nehmen wie Pickle,

01:54:54.600 --> 01:54:56.500
da muss man aufpassen, ähm,

01:54:56.540 --> 01:54:58.500
ja, es gibt noch in, in, in Python, äh,

01:54:59.260 --> 01:55:00.740
in Python selber, wenn ich jetzt überlege,

01:55:00.820 --> 01:55:02.800
gibt es noch, äh, eingebaute Geschichten, es gibt noch Marshall,

01:55:02.980 --> 01:55:04.540
das Modul, das macht sowas ähnliches wie

01:55:04.540 --> 01:55:06.840
JSON, bloß halt, äh, binär.

01:55:07.100 --> 01:55:08.060
Das ist auch noch ein Stückchen schneller.

01:55:09.240 --> 01:55:10.920
Und dann gibt es noch Shelf, glaube ich,

01:55:11.000 --> 01:55:13.100
das weiß ich aber nicht, hab's auch schon ganz lange nicht mehr verwendet.

01:55:14.040 --> 01:55:14.920
Ähm, und

01:55:14.920 --> 01:55:16.540
eben, wenn man jetzt aber nicht nur,

01:55:16.820 --> 01:55:18.600
äh, Daten, äh, äh,

01:55:18.700 --> 01:55:20.580
serialisieren will, sondern vielleicht auch Code mit,

01:55:20.780 --> 01:55:22.680
also komplette Objekte mit Funktionalität,

01:55:23.860 --> 01:55:24.900
dann, äh,

01:55:25.200 --> 01:55:25.940
ja, sowas wie Pickle.

01:55:26.220 --> 01:55:28.600
Und Pickle kann man auch schicken als Binär-File, dann einfach übers Netz,

01:55:28.680 --> 01:55:30.300
und dann kommt... Genau, man kann das in, äh,

01:55:30.300 --> 01:55:32.780
man verwandelt halt ein komplettes Objekt zum Beispiel in einen

01:55:32.780 --> 01:55:33.800
binären String,

01:55:34.480 --> 01:55:36.260
dann schickt man den irgendwie übers Netz, auf der anderen Seite

01:55:36.260 --> 01:55:38.600
deserialisiert man den, und dann hat man dieses Objekt

01:55:38.600 --> 01:55:41.060
wieder da. Das ist natürlich sehr praktisch.

01:55:41.500 --> 01:55:42.640
Was ein bisschen schlecht dran ist, ist,

01:55:42.700 --> 01:55:44.400
man muss halt sehr aufpassen, äh,

01:55:44.400 --> 01:55:46.120
äh, dass man dann führt der Code aus, ja,

01:55:46.200 --> 01:55:46.800
also wenn, äh,

01:55:46.820 --> 01:55:49.280
wenn einem jemand irgendwie, äh,

01:55:49.340 --> 01:55:50.440
der nicht vertrauenswürdig ist,

01:55:50.580 --> 01:55:52.760
irgendwie irgendwas Gepickeltes schickt,

01:55:53.320 --> 01:55:55.600
da kann beliebiger, kann beliebiger Code drin sein,

01:55:55.700 --> 01:55:57.380
ja, also wenn man das anpickelt,

01:55:57.520 --> 01:55:58.920
dann führt man das aus, was da drin steht.

01:55:59.580 --> 01:56:00.900
Das heißt, äh, ja, das sollte,

01:56:01.140 --> 01:56:03.580
das sollte man sich klar machen,

01:56:03.660 --> 01:56:04.580
dass das... Hier ist eine Bombe.

01:56:05.280 --> 01:56:07.440
Genau, dass man, also,

01:56:07.880 --> 01:56:09.460
ja, irgendwas, äh,

01:56:10.340 --> 01:56:11.920
anpickeln, was einem jemand gibt,

01:56:11.920 --> 01:56:14.100
ist so wie irgendwie Code ausführen, der einem jemand gibt,

01:56:14.180 --> 01:56:15.920
also das ist halt... Wenn ich ein Paket öffne, was man nach Hause

01:56:15.920 --> 01:56:16.800
geschenkt bekommen hat, der kann auch,

01:56:16.820 --> 01:56:18.800
ja, Briefbombe drin sein, man weiß es nie so genau.

01:56:20.100 --> 01:56:21.400
Das ist immer auch beim Essen, wenn man isst,

01:56:21.460 --> 01:56:23.060
was man nicht kennt, dann immer Vorkost da dann.

01:56:25.980 --> 01:56:26.260
Ja.

01:56:27.540 --> 01:56:28.880
Man weiß es nie so genau, also, ne,

01:56:28.880 --> 01:56:30.960
die Paranoia kann ja beliebig weit getrieben werden.

01:56:31.380 --> 01:56:33.180
Genau, genau, genau. Äh, Pickel,

01:56:33.360 --> 01:56:35.460
lass mal überlegen, gibt's noch, es gibt da noch diverse,

01:56:35.840 --> 01:56:37.460
es gibt da noch für den wissenschaftlichen Bereich

01:56:37.460 --> 01:56:39.220
ein paar Sachen, es gibt noch HDF5,

01:56:39.220 --> 01:56:39.460
äh,

01:56:40.100 --> 01:56:42.580
äh, wie heißt das Ding, NetCD,

01:56:43.060 --> 01:56:45.380
äh, ich hab's jetzt wieder vergessen,

01:56:46.680 --> 01:56:46.800
äh,

01:56:46.820 --> 01:56:48.820
ähm, wie der Standard ist, also wie,

01:56:49.000 --> 01:56:51.280
ja, es gibt so eben für wissenschaftliche Daten,

01:56:51.860 --> 01:56:53.200
gibt's noch Standards, wie man,

01:56:53.940 --> 01:56:55.080
äh, wie man Sachen speichert,

01:56:55.120 --> 01:56:56.220
die noch so ein bisschen anders sind,

01:56:57.400 --> 01:56:59.240
äh, NetCDF, glaube ich,

01:56:59.280 --> 01:57:01.120
das ist, ja, so, und HDF5

01:57:01.120 --> 01:57:03.280
ist einer der, es gehört da irgendwie

01:57:03.280 --> 01:57:04.380
mit rein in diese Reihenfolge.

01:57:04.420 --> 01:57:05.740
Ja, das hört sich irgendwie total kapiert an.

01:57:05.960 --> 01:57:08.360
Äh, ja, ähm, und, ähm,

01:57:09.360 --> 01:57:11.140
NumPy-Arrays haben auch nochmal eine eigene Möglichkeit,

01:57:11.260 --> 01:57:12.480
wie man sie serialisieren kann,

01:57:13.060 --> 01:57:14.980
man kann ja auch Memory mappen, äh,

01:57:15.540 --> 01:57:16.180
ähm,

01:57:16.820 --> 01:57:18.880
ja, oder, ich mein, CSV ist auch eine Möglichkeit,

01:57:19.000 --> 01:57:20.920
Sachen zu serialisieren, CSV ist auch wieder so ein Format,

01:57:21.660 --> 01:57:22.920
so eigene, furchte,

01:57:23.060 --> 01:57:24.640
fürchterliche, schreckliche Sachen mit sich bringen,

01:57:25.040 --> 01:57:26.960
aber, äh,

01:57:27.640 --> 01:57:28.680
also, äh,

01:57:28.680 --> 01:57:30.740
in anderer Sicht ist es auch wieder ganz gut, also,

01:57:30.920 --> 01:57:33.200
oft, äh, würde ich sagen, dass, äh,

01:57:33.260 --> 01:57:34.860
wenn man die Wahl hat zwischen CSV und XML,

01:57:35.060 --> 01:57:36.120
ist CSV die bessere Wahl,

01:57:36.960 --> 01:57:38.620
aber, äh, ja,

01:57:39.120 --> 01:57:40.040
ähm,

01:57:40.880 --> 01:57:42.860
tja, ja, aber das,

01:57:42.960 --> 01:57:44.380
das war's im Grunde eigentlich,

01:57:44.380 --> 01:57:46.540
ja, haben wir noch irgendeine wichtige Serialisierungsgeschichte?

01:57:46.820 --> 01:57:48.280
Ja, ich glaube, also, wir wollen ja jetzt auch,

01:57:48.400 --> 01:57:49.660
eigentlich wollen wir ja nur eine Minute reden, ich glaube,

01:57:49.740 --> 01:57:50.700
dann halten wir uns jetzt voll.

01:57:50.700 --> 01:57:51.460
Ui, ui, ui, ui.

01:57:52.240 --> 01:57:54.960
Ja, ich hab jetzt noch so ein paar Themen, die sind irgendwie jetzt alle aber sehr unzusammenhängend,

01:57:55.040 --> 01:57:56.640
auch, ähm, ich überlege gerade,

01:57:56.780 --> 01:57:58.380
wo ich damit jetzt noch anfangen soll, ich glaube,

01:57:58.460 --> 01:58:00.180
am Memory Management hatten wir schon mal gesprochen, ich glaube,

01:58:00.220 --> 01:58:02.500
in einer der ersten Folgen, da haben wir ja über den JIT und den GIL gesprochen,

01:58:02.720 --> 01:58:05.040
an den, äh, Just-in-Time-Compiler

01:58:05.040 --> 01:58:06.520
und den Global Interpreter-Log,

01:58:07.280 --> 01:58:08.940
ähm, dann, äh, hab ich jetzt noch stehen,

01:58:09.000 --> 01:58:10.620
äh, das Konzept von MapReduce, aber ich weiß nicht,

01:58:10.620 --> 01:58:12.840
ob das jetzt hier zugehört, dass das irgendwie nicht ganz

01:58:12.840 --> 01:58:14.440
da reinpasst. Nee, ich glaube auch, es ist auch so ein bisschen veraltet,

01:58:14.700 --> 01:58:16.000
also, dass man zwischendurch macht das keiner mehr.

01:58:16.500 --> 01:58:18.680
Und dann, äh, was mich aber natürlich noch interessiert,

01:58:18.740 --> 01:58:20.360
wenn man halt debuggen möchte, was da irgendwie

01:58:20.360 --> 01:58:22.520
der Zeug ist, dann gibt's da irgendwie so ein bisschen

01:58:22.520 --> 01:58:24.100
so, ich nenn's jetzt mal Deep-Debugging,

01:58:24.220 --> 01:58:26.580
das heißt, man kann, äh, Deer auf irgendwelche

01:58:26.580 --> 01:58:28.340
Feele spawnen oder Help aufrufen

01:58:28.340 --> 01:58:30.240
und so, was gibt's denn da noch und wie würde man

01:58:30.240 --> 01:58:32.180
sich dann angucken, was überhaupt möglich ist

01:58:32.180 --> 01:58:34.600
mit so Objekten, die man da, äh, zurückbekommt,

01:58:34.680 --> 01:58:36.200
wo man nicht genau weiß, woran liegt denn das jetzt,

01:58:36.740 --> 01:58:37.900
guckt man denn da genauer rein?

01:58:37.920 --> 01:58:40.760
Naja, ich glaub, das ist schon, äh, also, Help zeigt halt den...

01:58:40.760 --> 01:58:42.280
Also, macht man Help, das sind Funktionen, die

01:58:42.280 --> 01:58:44.380
man außen rumschmeißt und was, was zurückkommt, oder?

01:58:45.140 --> 01:58:46.480
Mhm, äh, ja, aber das, äh,

01:58:46.780 --> 01:58:48.460
also, an den Objekten hängen halt auch

01:58:48.460 --> 01:58:50.220
immer Dinge dran, also, zum Beispiel, man an dem

01:58:50.220 --> 01:58:52.400
Funktionsobjekt hängt halt auch immer die Dokumentation,

01:58:52.400 --> 01:58:54.360
also, der Dockstring hängt da halt mit dran, den man sich dann

01:58:54.360 --> 01:58:56.180
angucken kann und ich weiß nicht genau, was Help macht,

01:58:56.260 --> 01:58:58.420
aber Help, glaub ich, wird sowas tun, wie

01:58:58.420 --> 01:59:00.520
die Dockstrings nehmen und anzeigen,

01:59:00.940 --> 01:59:02.580
mehr oder weniger, ähm,

01:59:03.000 --> 01:59:04.640
und, äh, Deer zeigt halt

01:59:04.640 --> 01:59:06.640
alle Attribute und, äh, Methoden

01:59:06.640 --> 01:59:07.760
oder so an einem Objekt,

01:59:08.280 --> 01:59:10.220
die da so dranhängen, äh,

01:59:10.340 --> 01:59:10.640
und

01:59:10.760 --> 01:59:11.620
dann, äh, ja,

01:59:12.760 --> 01:59:14.480
also, zumindest, äh, kann man sich dann,

01:59:14.640 --> 01:59:16.400
zeigt das auch die Funktion Signature, glaub ich, an,

01:59:16.660 --> 01:59:18.400
noch... Was gibt's denn noch?

01:59:18.560 --> 01:59:20.560
Äh, ich glaub, ne, mehr, mehr verwende ich

01:59:20.560 --> 01:59:22.060
eigentlich auch, äh, praktisch nicht.

01:59:23.460 --> 01:59:24.660
Das ist dieses MRO, ne,

01:59:24.660 --> 01:59:26.540
dieses Basis, also, wenn man so eine von diesen

01:59:26.540 --> 01:59:28.740
Objekten, die man mit Deer dann rausbekommt, hat, sich's anguckt,

01:59:29.160 --> 01:59:30.580
dann bekommt man natürlich noch viel mehr Informationen,

01:59:30.760 --> 01:59:32.680
weil diese ganzen, ähm, Magic Methods

01:59:32.680 --> 01:59:34.800
und Meta-Attribute irgendwie von den Klassen dranhängen,

01:59:35.140 --> 01:59:36.700
dass man, zum Beispiel jetzt, ne, mit Basis

01:59:36.700 --> 01:59:38.620
sehen kann, welche, äh, Oberklassen

01:59:38.620 --> 01:59:40.340
hat denn überhaupt das Ding, wo ich dann drin bin, so,

01:59:40.340 --> 01:59:40.620
und so. Ah, okay.

01:59:40.760 --> 01:59:42.000
Cool. Nee, hab ich noch nie verwendet, glaub ich.

01:59:42.520 --> 01:59:44.640
Da kann man halt so ein bisschen tiefer reingucken in dieses, äh,

01:59:44.640 --> 01:59:46.820
Vererbungshierarchie-Ding und, ähm, dieses, äh,

01:59:46.840 --> 01:59:48.480
MRO, also diese Method Resolution Order,

01:59:48.580 --> 01:59:51.540
zeigt dann vielleicht genau, welches von den, äh,

01:59:51.600 --> 01:59:52.880
Dingen, die dann aufgerufen worden ist,

01:59:52.900 --> 01:59:54.560
aufgerufen worden ist, von den Methoden, die man jetzt

01:59:54.560 --> 01:59:56.640
in reiner Weise überschrieben hat, und was da eigentlich

01:59:56.640 --> 01:59:58.500
hinter steckt, damit man vielleicht weiß, oh, es wurde etwas

01:59:58.500 --> 01:59:59.960
Falsches aufgerufen, also so kann man so...

01:59:59.960 --> 02:00:01.940
mal gucken, wenn irgendwas schief geht, wo man überhaupt nicht

02:00:01.940 --> 02:00:03.660
weiß, was man da gemacht hat, dass man nicht irgendeinen

02:00:03.660 --> 02:00:06.160
Komma gegessen hat, wie man dann da reinkommt.

02:00:06.260 --> 02:00:07.560
Wobei da dann vielleicht auch

02:00:07.560 --> 02:00:09.800
eine bessere Wahl wäre, einfach

02:00:09.800 --> 02:00:10.320
direkt einen

02:00:10.320 --> 02:00:12.800
T-Bugger zu verwenden.

02:00:13.520 --> 02:00:14.920
Ja, welchen würdest du empfehlen?

02:00:15.180 --> 02:00:17.800
PDB ist halt so das, was man kann ja auch inzwischen...

02:00:17.800 --> 02:00:19.580
Was macht PDB? Also der stoppt den Code

02:00:19.580 --> 02:00:21.620
zur Ausführzeit, man hat eine Shell und kann

02:00:21.620 --> 02:00:21.820
dann da hochgehen.

02:00:21.820 --> 02:00:22.600
Man kann es halt auch irgendwie

02:00:22.600 --> 02:00:25.260
im Code halt rein

02:00:25.260 --> 02:00:26.440
set trace,

02:00:26.440 --> 02:00:31.440
schreibst halt einfach

02:00:31.440 --> 02:00:33.160
deinen Code rein und dann hast du da halt

02:00:33.160 --> 02:00:35.020
einen... Stoppt halt

02:00:35.020 --> 02:00:37.220
die Ausführungen an der Stelle und du

02:00:37.220 --> 02:00:39.500
kriegst halt ein interaktives Prompt, an dem du halt

02:00:39.500 --> 02:00:41.320
gucken kannst, was steht denn zum Beispiel in den Variablen drin.

02:00:42.240 --> 02:00:43.380
Und dann kannst du halt auch sagen, okay,

02:00:43.500 --> 02:00:45.360
ich gehe jetzt hier weiter oder ich überspringe das

02:00:45.360 --> 02:00:47.260
und gucke dann wieder, was ist denn da los.

02:00:48.400 --> 02:00:48.720
Genau.

02:00:48.720 --> 02:00:50.960
Und dann weißt du ja genau, wo du bist.

02:00:53.060 --> 02:00:54.660
Also das ist eine schöne Geschichte.

02:00:54.760 --> 02:00:56.420
Ich weiß jetzt nicht, seit wann

02:00:56.420 --> 02:00:58.240
das Tracing eingebaut ist.

02:00:58.400 --> 02:01:00.780
Das ist noch nicht so lange her, glaube ich.

02:01:01.540 --> 02:01:02.120
Ja, aber

02:01:02.120 --> 02:01:04.600
Debugger hilft

02:01:04.600 --> 02:01:05.980
einem da schon deutlich.

02:01:07.680 --> 02:01:08.340
Funktioniert halt auch

02:01:08.340 --> 02:01:09.600
in Django oder so.

02:01:10.380 --> 02:01:12.220
Kriegt man das über die Webseite halt dann

02:01:12.220 --> 02:01:13.120
entsprechend schnell.

02:01:13.200 --> 02:01:14.280
Ich glaube, das gehört auch mit der VS Code.

02:01:14.280 --> 02:01:15.900
Also der Editor hat das irgendwie auch implementiert.

02:01:15.900 --> 02:01:16.880
Ja, das muss ich auch nochmal angucken.

02:01:17.520 --> 02:01:18.800
Gar nicht richtig benutzt.

02:01:18.920 --> 02:01:21.420
Man kann halt dann so Debug-Stops setzen und so.

02:01:22.720 --> 02:01:23.680
Ja, Breakpoints.

02:01:23.900 --> 02:01:24.660
Introspection, ja genau.

02:01:26.420 --> 02:01:28.280
Ja, ich habe jetzt noch zwei andere wieder.

02:01:28.380 --> 02:01:29.260
Punkt drauf, die nichts mehr da zu tun.

02:01:29.340 --> 02:01:31.380
Zwar einmal, wie löst man Multithreading in Python?

02:01:32.700 --> 02:01:34.200
Ja, das funktioniert

02:01:34.200 --> 02:01:35.480
so wie sonst auch.

02:01:35.760 --> 02:01:37.720
Also tatsächlich sind auch Threads in Python

02:01:37.720 --> 02:01:39.880
halt tatsächlich ganz normale, bilden sich ab

02:01:39.880 --> 02:01:41.760
auf Threads im Betriebssystem.

02:01:44.340 --> 02:01:45.540
Es ist halt nur so, dass

02:01:45.540 --> 02:01:47.380
die nicht wirklich

02:01:47.380 --> 02:01:49.040
parallel Dinge tun können.

02:01:49.940 --> 02:01:51.440
Auf unterschiedlichen CPUs sozusagen.

02:01:51.540 --> 02:01:53.120
Sie können schon parallel Sachen machen, aber halt

02:01:53.120 --> 02:01:54.700
natürlich dann nicht so wirklich.

02:01:55.100 --> 02:01:55.460
Weil,

02:01:56.420 --> 02:01:58.620
nicht gleichzeitig, weil

02:01:58.620 --> 02:02:00.700
Sachen auf einer CPU natürlich doch dann

02:02:00.700 --> 02:02:02.760
irgendwie mal sequenziell abgearbeitet werden.

02:02:02.760 --> 02:02:03.040
Aber,

02:02:04.240 --> 02:02:05.960
ja,

02:02:06.580 --> 02:02:09.680
man benutzt die aber,

02:02:10.200 --> 02:02:11.400
also daher kann man sie nicht

02:02:11.400 --> 02:02:12.860
dafür verwenden, um

02:02:12.860 --> 02:02:15.820
Berechnungen zu parallelisieren.

02:02:15.940 --> 02:02:17.600
Weil eben dafür müsste man es ja auf Prozessoren

02:02:17.600 --> 02:02:19.300
aufteilen können. Das geht nicht.

02:02:20.080 --> 02:02:20.500
Aber,

02:02:20.800 --> 02:02:22.760
um I.O. zu multiplexen,

02:02:23.520 --> 02:02:25.160
geht das ja ganz hervorragend.

02:02:25.260 --> 02:02:26.380
Und das funktioniert gut.

02:02:26.420 --> 02:02:28.260
Kann man dafür benutzen.

02:02:29.620 --> 02:02:30.780
Ist jetzt nicht so die

02:02:30.780 --> 02:02:32.420
moderne

02:02:33.000 --> 02:02:34.080
Art, das zu tun.

02:02:35.420 --> 02:02:36.560
Da würde man wahrscheinlich eher

02:02:36.560 --> 02:02:37.900
sowas wie Async.io nehmen oder so.

02:02:38.800 --> 02:02:40.860
Aber man kann auch Threads benutzen.

02:02:41.300 --> 02:02:42.360
Völlig okay.

02:02:42.940 --> 02:02:44.440
Also Async.io macht dann echt das Multithreading

02:02:44.440 --> 02:02:45.240
auf Multiprozessoren?

02:02:45.260 --> 02:02:48.020
Nee, das macht kein Threading. Async.io ist wieder eine andere Geschichte.

02:02:48.220 --> 02:02:48.540
Was ist das?

02:02:49.060 --> 02:02:51.440
Async.io ist, ja,

02:02:52.680 --> 02:02:53.960
kann man sagen, einmal ein Event-Loop,

02:02:53.960 --> 02:02:56.300
sozusagen so ähnlich wie in Node.js,

02:02:56.420 --> 02:02:56.860
oder so auch,

02:02:58.000 --> 02:03:00.000
wo halt immer geguckt wird, was gibt es denn jetzt gerade zu tun,

02:03:00.100 --> 02:03:01.720
oder so, und dann macht man halt an einer bestimmten Stelle weiter.

02:03:02.500 --> 02:03:04.040
Aber vor allen Dingen

02:03:04.040 --> 02:03:05.680
halt auch eine Syntax, wie man das

02:03:05.680 --> 02:03:08.000
so hinschreibt, dass das automatisch

02:03:08.000 --> 02:03:10.040
gehandelt werden kann.

02:03:10.260 --> 02:03:11.760
Also ich kann halt sozusagen

02:03:11.760 --> 02:03:14.120
in Python Funktionen als Async

02:03:14.120 --> 02:03:16.180
deklarieren, und dann

02:03:16.180 --> 02:03:17.880
kann ich halt die

02:03:17.880 --> 02:03:19.880
Ausführungen, wenn die zum Beispiel blockieren,

02:03:19.980 --> 02:03:21.760
halt unterbrechen. Die werden dann später weiter ausgeführt,

02:03:21.760 --> 02:03:22.960
wenn es halt wieder was zu tun gibt.

02:03:24.540 --> 02:03:26.060
ja,

02:03:26.420 --> 02:03:28.740
das,

02:03:30.260 --> 02:03:31.980
ja, aber das müssten wir, wenn man das wirklich erklären

02:03:31.980 --> 02:03:34.120
würde, das funktioniert, müssen wir nochmal eine Folge dazu machen,

02:03:35.080 --> 02:03:35.480
das,

02:03:36.000 --> 02:03:38.160
eben, damit kann man halt auch IOMultiplexen

02:03:38.160 --> 02:03:40.240
und das Ganze

02:03:40.240 --> 02:03:42.180
in einer etwas intuitiveren Art

02:03:42.180 --> 02:03:43.980
hinschreiben, als wenn man das jetzt mit Threading

02:03:43.980 --> 02:03:45.340
machen würde. Weil wenn man das mit Threading,

02:03:45.720 --> 02:03:48.020
mit dem Threading-Modul macht, dann wird es

02:03:48.020 --> 02:03:50.560
sehr schnell auch sehr unintuitiv.

02:03:50.900 --> 02:03:51.680
Und was man auch

02:03:51.680 --> 02:03:53.840
irgendwie dabei beachten muss,

02:03:53.880 --> 02:03:54.800
ist halt, wenn man,

02:03:54.800 --> 02:03:55.120
also,

02:03:56.420 --> 02:03:57.900
wenn man da Tracebacks kriegt irgendwo in

02:03:57.900 --> 02:03:59.900
Workern, die halt in unterschiedlichen

02:03:59.900 --> 02:04:01.520
Threads laufen, das kann sehr,

02:04:01.880 --> 02:04:04.020
also man, ich meine, das ist halt sowieso

02:04:04.020 --> 02:04:05.900
das Problem, wenn man jetzt irgendwie Dinge asynchron

02:04:05.900 --> 02:04:07.840
tut, oder so, die halt so irgendwie,

02:04:09.120 --> 02:04:10.280
man hat nicht mehr so

02:04:10.280 --> 02:04:11.260
wirklich einen linearen,

02:04:12.180 --> 02:04:13.960
der Code läuft nicht mehr so linear durch, sondern

02:04:13.960 --> 02:04:16.080
man weiß halt nie so genau, wo man gerade ist

02:04:16.080 --> 02:04:18.020
und was da gerade passiert. Und wenn man da

02:04:18.020 --> 02:04:19.980
Tracebacks kriegt und viele

02:04:19.980 --> 02:04:21.660
Threads verwendet, und da, dann

02:04:21.660 --> 02:04:24.220
weiß man manchmal echt gar nicht, was da gerade passiert ist.

02:04:24.500 --> 02:04:26.220
Manchmal kommt man in Zuständen raus, die sehr eigenartig

02:04:26.420 --> 02:04:28.060
sind, und das ist dann immer sehr hässlich

02:04:28.060 --> 02:04:30.020
zu debuggen. Also das ist, und das geht

02:04:30.020 --> 02:04:32.040
mit Async.io deutlich besser.

02:04:32.180 --> 02:04:34.080
Also es ist halt deutlich eher so,

02:04:34.220 --> 02:04:36.300
dass man Code so hinschreibt,

02:04:36.440 --> 02:04:37.840
als wäre er synchron, quasi,

02:04:38.300 --> 02:04:40.040
aber er dann halt automatisch

02:04:40.040 --> 02:04:41.560
mehr oder weniger Async, also

02:04:41.560 --> 02:04:43.900
so ist das halt in den Stellen, wo

02:04:43.900 --> 02:04:46.040
man auf ein Syscall wartet oder so, wo es blockiert,

02:04:47.020 --> 02:04:48.160
da macht

02:04:48.160 --> 02:04:49.880
man halt an einer anderen Stelle, wo man halt

02:04:49.880 --> 02:04:52.000
weitermachen kann, weiter. Und erst dann,

02:04:52.060 --> 02:04:54.380
wenn dann irgendein

02:04:54.380 --> 02:04:56.020
Lese, irgendein

02:04:56.020 --> 02:04:57.960
Read von irgendwie Netzwerkgeschichte zurückkommt,

02:04:58.100 --> 02:04:59.380
dann geht es halt dann da wieder weiter.

02:05:00.020 --> 02:05:01.740
Und ja,

02:05:01.920 --> 02:05:03.640
also insofern würde ich sagen, also wenn man

02:05:03.640 --> 02:05:05.540
jetzt erst damit anfängt, dann ist Async.io wahrscheinlich

02:05:05.540 --> 02:05:07.580
die interessantere Geschichte, die man sich angucken

02:05:07.580 --> 02:05:09.620
sollte, weil es mehr

02:05:09.620 --> 02:05:10.940
aussieht wie ein normales Programm.

02:05:12.180 --> 02:05:13.660
Aber Threading kann man

02:05:13.660 --> 02:05:15.720
durchaus auch machen. Und es ist wahrscheinlich

02:05:15.720 --> 02:05:17.640
sogar ein bisschen schneller, wenn man wenig Threads hat.

02:05:18.580 --> 02:05:19.760
Aber, ach, das ist eigentlich

02:05:19.760 --> 02:05:21.060
auch furchtbar, das spielt alles keine große Rolle.

02:05:22.340 --> 02:05:23.500
Okay. Ja,

02:05:23.640 --> 02:05:24.680
dann was ist Covered?

02:05:26.020 --> 02:05:27.060
Oh, wuh!

02:05:27.920 --> 02:05:28.480
Ganz interessant.

02:05:29.920 --> 02:05:31.380
Ja, meinst du das

02:05:31.380 --> 02:05:33.460
Paket oder das Modul? Achso, die Coverage.

02:05:33.680 --> 02:05:34.600
Ja, sozusagen, wie viel

02:05:34.600 --> 02:05:36.280
ähm,

02:05:37.740 --> 02:05:39.660
ja, damit gibt man sozusagen an, wie viel

02:05:39.660 --> 02:05:41.320
Prozent des

02:05:41.320 --> 02:05:42.880
Codes

02:05:42.880 --> 02:05:45.560
durchlaufen wird, den man geschrieben hat, wenn man

02:05:45.560 --> 02:05:47.660
die Tests, also man kann ja halt gucken,

02:05:48.260 --> 02:05:49.460
auch, das geht natürlich im Teil ganz gut,

02:05:49.900 --> 02:05:51.380
gibt es auch ein Modul-Coverage-PY,

02:05:51.620 --> 02:05:53.520
das das macht, das halt guckt,

02:05:53.520 --> 02:05:55.620
wie viele von den Zeilen wurden denn

02:05:55.620 --> 02:05:57.680
aufgerufen, wenn ich jetzt die Tests

02:05:57.680 --> 02:05:59.400
durchlaufen lasse von meinem Gesamtding.

02:05:59.520 --> 02:06:01.360
Und das ist dann halt sozusagen, die Coverage ist halt sozusagen

02:06:01.360 --> 02:06:03.580
die Prozentzahl. Und wenn ich halt 70% habe,

02:06:03.660 --> 02:06:04.180
dann ist es halt

02:06:04.180 --> 02:06:07.400
besser, als wenn ich 50% habe.

02:06:07.660 --> 02:06:08.720
Wie viel sollte man denn davon haben?

02:06:09.180 --> 02:06:11.160
Es gibt Leute, die sagen, man sollte 100% haben.

02:06:11.680 --> 02:06:12.500
150%?

02:06:13.120 --> 02:06:14.200
Weiß ich nicht so genau,

02:06:15.120 --> 02:06:16.520
ob das ein sinnvolles Ziel ist,

02:06:16.720 --> 02:06:19.500
weil es wird dann, manche Sachen sind einfach schwer zu testen und

02:06:19.500 --> 02:06:21.580
irgendwann

02:06:21.580 --> 02:06:23.520
wird es halt dann sehr aufwendig

02:06:23.520 --> 02:06:25.480
und, also die erst

02:06:25.480 --> 02:06:27.100
80% so stabil, wie das so immer ist,

02:06:27.280 --> 02:06:29.600
die gehen relativ einfach und dann die letzten 20%

02:06:29.600 --> 02:06:30.680
brauchen dann nochmal

02:06:30.680 --> 02:06:33.220
80% der Zeit irgendwie,

02:06:33.660 --> 02:06:35.300
weil das dann halt alles so fiese Fälle sind,

02:06:35.320 --> 02:06:37.300
die man nicht gut testen kann. Und dann ist halt

02:06:37.300 --> 02:06:39.080
die Frage, ist es noch sinnvoll, da so viel Zeit reinzustecken,

02:06:39.180 --> 02:06:41.240
weil den größten Nutzen hat man dann vielleicht

02:06:41.240 --> 02:06:42.920
schon gehabt, irgendwie in dem

02:06:42.920 --> 02:06:45.240
Code, der halt einfach

02:06:45.240 --> 02:06:47.280
zu testen war. Aber auch da

02:06:47.280 --> 02:06:49.260
kann man das natürlich vereinfachen, indem man Code so schreibt,

02:06:49.360 --> 02:06:51.220
dass man ihn einfach testen kann. Also manchmal mache ich

02:06:51.220 --> 02:06:52.800
Funktionen, schreibe ich Funktionen nur deswegen,

02:06:53.420 --> 02:06:55.100
um diese

02:06:55.480 --> 02:06:56.740
Funktionen einzeln testen zu können.

02:06:58.320 --> 02:06:59.140
Und, ja,

02:06:59.240 --> 02:07:01.100
oder manchmal macht es dann

02:07:01.100 --> 02:07:02.960
Dinge auf eine bestimmte Art zu strukturieren,

02:07:03.020 --> 02:07:04.920
sodass man sie halt leichter testen kann, als wenn man jetzt irgendwie

02:07:04.920 --> 02:07:06.880
alles in einer Funktion hat oder so, dann ist halt

02:07:06.880 --> 02:07:07.820
einfach schwer, die zu testen.

02:07:09.380 --> 02:07:11.000
Ja, und möglichst

02:07:11.000 --> 02:07:12.420
hohe Coverage ist natürlich gut. Also

02:07:12.420 --> 02:07:14.900
ich bin jetzt nicht so, ich will jetzt nicht sagen,

02:07:14.980 --> 02:07:16.900
dass 100% unbedingt notwendig ist, aber viel wäre

02:07:16.900 --> 02:07:17.220
schon gut.

02:07:18.700 --> 02:07:21.160
Und dann gibt es natürlich nochmal auch feine Unterschiede,

02:07:21.280 --> 02:07:22.260
ob man jetzt nur

02:07:23.260 --> 02:07:24.740
irgendwie durch den Code durchgelaufen ist,

02:07:24.740 --> 02:07:26.200
so hat man aber auch wirklich alle,

02:07:26.520 --> 02:07:28.180
gibt es viele unterschiedliche,

02:07:28.740 --> 02:07:29.960
also wenn man sowas wie

02:07:29.960 --> 02:07:32.120
Condition, so

02:07:32.120 --> 02:07:34.540
If-Else-Geschichten hat, werden auch

02:07:34.540 --> 02:07:36.760
wirklich, hat man sichergestellt, dass man alle Branches,

02:07:36.880 --> 02:07:38.780
die dann passieren können, durchlaufen hat und so.

02:07:39.240 --> 02:07:40.400
Insofern ist nicht mehr nicht so ganz klar,

02:07:40.520 --> 02:07:42.340
was gemeint ist, wenn man jetzt Coverage sagt.

02:07:43.220 --> 02:07:44.500
Und, ja,

02:07:44.640 --> 02:07:45.400
das kann man dann auch nochmal,

02:07:46.400 --> 02:07:48.600
also ich glaube, die ursprüngliche Geschichte ist

02:07:48.600 --> 02:07:50.660
nur so, es ist egal, es müssen nicht alle

02:07:50.660 --> 02:07:51.660
Branches durchlaufen werden.

02:07:52.840 --> 02:07:53.960
Und das will man

02:07:53.960 --> 02:07:54.660
vielleicht auch anders haben.

02:07:54.740 --> 02:07:56.800
Also ich glaube, das kann man auch bei Coverage noch einstellen.

02:07:58.280 --> 02:07:58.900
Etwas feiner.

02:07:59.060 --> 02:08:00.100
Aber, ja, genau.

02:08:00.260 --> 02:08:02.760
Test-Coverage ist halt sozusagen ein Maß dafür, wie viel

02:08:02.760 --> 02:08:04.100
von dem Code, der

02:08:04.100 --> 02:08:06.700
in einer Bibliothek ist oder so, wie viel

02:08:06.700 --> 02:08:08.280
davon ist eigentlich durch Tests

02:08:08.280 --> 02:08:10.820
überprüft oder ist überhaupt

02:08:10.820 --> 02:08:12.860
mal ausgeführt worden bei dem Test.

02:08:15.900 --> 02:08:16.800
Ja, dann haben wir

02:08:16.800 --> 02:08:18.380
fast ja schon die letzte Frage. Ich glaube, wir sind da schon

02:08:18.380 --> 02:08:19.920
lange wieder heute dabei.

02:08:20.840 --> 02:08:22.400
Und zwar auch wieder eine

02:08:22.400 --> 02:08:24.180
höhere Frage. Wie man die Performance,

02:08:24.180 --> 02:08:26.180
die Speichernutzung der Codes prüfen

02:08:26.180 --> 02:08:26.900
und vergleichen kann.

02:08:31.620 --> 02:08:32.440
Ja, also

02:08:32.440 --> 02:08:36.140
was ich oft mache,

02:08:36.360 --> 02:08:38.060
ist tatsächlich, aber ich meine,

02:08:38.140 --> 02:08:40.000
ist ja die Frage, wann das Sinn macht. Das macht eigentlich

02:08:40.000 --> 02:08:42.120
erst dann Sinn, wenn man viel Hauptspeicher verbraucht.

02:08:42.760 --> 02:08:44.180
Und ich mache das tatsächlich

02:08:44.180 --> 02:08:46.280
oft so, dass ich einfach mir

02:08:46.280 --> 02:08:48.340
die Ausgabe

02:08:48.340 --> 02:08:49.040
von Top angucke.

02:08:50.020 --> 02:08:52.180
Und dann sehe ich schon...

02:08:52.180 --> 02:08:53.540
Wie viel Speicher noch frei ist.

02:08:54.180 --> 02:08:56.100
Ja, und wie viel Speicher

02:08:56.100 --> 02:08:58.240
verbraucht ein Prozess. Und wenn

02:08:58.240 --> 02:09:00.400
dann halt irgendwas läuft, dann weiß ich

02:09:00.400 --> 02:09:01.920
ungefähr, wie viel Speicher das verbrauchen sollte.

02:09:02.500 --> 02:09:04.220
Und wenn das doppelt oder dreimal so viel verbraucht,

02:09:04.360 --> 02:09:06.240
dann weiß ich,

02:09:06.280 --> 02:09:08.020
wenn ich da ein Problem habe und vielleicht nochmal irgendwas machen muss.

02:09:09.160 --> 02:09:10.500
Es gibt aber auch systematische

02:09:10.500 --> 02:09:12.500
Ansätze. Also es gibt

02:09:12.500 --> 02:09:14.360
zum Beispiel auch eingebauten Profiler

02:09:14.360 --> 02:09:16.700
in Python.

02:09:16.820 --> 02:09:18.340
C-Profile heißt, glaube ich, das Modul.

02:09:19.060 --> 02:09:19.200
Genau.

02:09:20.000 --> 02:09:22.360
Das kann aber mit Memory-Geschichten nicht so viel machen.

02:09:23.360 --> 02:09:24.160
Für Memory-Geschichten,

02:09:24.180 --> 02:09:25.140
für Memory-Sachen, glaube ich,

02:09:25.380 --> 02:09:28.240
nimmt man dann eher so ein bisschen K-Cache-Grind oder sowas.

02:09:28.420 --> 02:09:29.180
Aber das ist...

02:09:29.180 --> 02:09:32.360
Aber wenn man das jetzt im Jupyter-Notebook machen möchte,

02:09:32.420 --> 02:09:34.380
weil man jetzt keinen Pop hat oder sowas...

02:09:34.380 --> 02:09:35.100
Naja, du kannst dir halt

02:09:35.100 --> 02:09:37.600
von den Datenstrukturen anzeigen lassen,

02:09:37.800 --> 02:09:39.400
wie viel Speicher sie verbrauchen.

02:09:40.560 --> 02:09:41.720
Da habe ich jetzt auch wieder vergessen,

02:09:41.820 --> 02:09:43.560
du kannst in einem

02:09:43.560 --> 02:09:45.700
Panas-Data-Frame sagen, irgendwie

02:09:45.700 --> 02:09:47.320
meminfo oder info oder sowas,

02:09:47.460 --> 02:09:49.020
und dann deep gleich true oder sowas.

02:09:49.360 --> 02:09:52.000
Dann geht das halt, macht das rekursiv,

02:09:52.000 --> 02:09:54.080
geht das durch diesen Data-Frame durch und guckt halt,

02:09:54.180 --> 02:09:55.300
wie viel Hauptspeicher

02:09:55.300 --> 02:09:57.580
brauchen da all die Dinge, die da drin sind,

02:09:57.640 --> 02:09:58.840
und sagt dir halt am Ende eine Zahl.

02:09:59.100 --> 02:10:02.360
Und dann weißt du halt, okay, in diesem Ding steckt so viel Speicher drin.

02:10:03.720 --> 02:10:04.280
Dein ganzes

02:10:04.280 --> 02:10:06.000
Jupyter-Notebook, also du kannst dir deine

02:10:06.000 --> 02:10:07.140
einzelnen Datenstrukturen angucken.

02:10:07.280 --> 02:10:10.200
Bei NumPy-Arrays ist es halt viel einfacher noch.

02:10:10.360 --> 02:10:11.800
Ich glaube, da gibt es auch eine Funktion, die einem sagt,

02:10:11.900 --> 02:10:13.780
welche Hauptspeicher irgendwie ein Array

02:10:13.780 --> 02:10:15.320
verwendet, aber da ist es ja einfach,

02:10:15.420 --> 02:10:17.220
du kannst dir den D-Type angucken von dem Ding,

02:10:17.660 --> 02:10:20.160
und du kannst dir auch angucken mit Shape, wie viel da drin liegt,

02:10:20.160 --> 02:10:21.700
und dann multiplizierst du das einfach mit,

02:10:22.200 --> 02:10:24.020
wie viel Bit hat halt hier

02:10:24.020 --> 02:10:26.040
irgendwie der Typ, den ich da verwende, mal Anzahl

02:10:26.040 --> 02:10:28.080
Einträge, und dann weißt du, wie groß das ist, weil da ist es halt

02:10:28.080 --> 02:10:28.420
sehr einfach.

02:10:32.060 --> 02:10:34.080
Also so kann man bei einzelnen Sachen rausfinden, wie viel

02:10:34.080 --> 02:10:36.060
Hauptspeicher die verbrauchen, weil das, wie viel das

02:10:36.060 --> 02:10:38.140
Jupyter-Notebook insgesamt verbraucht, siehst du halt

02:10:38.140 --> 02:10:38.860
im Top.

02:10:39.780 --> 02:10:40.920
Der Speed?

02:10:42.300 --> 02:10:43.540
Ja, da brauchst du wahrscheinlich auch,

02:10:43.800 --> 02:10:45.640
kannst du natürlich auch global

02:10:45.640 --> 02:10:47.840
das bestimmen,

02:10:47.840 --> 02:10:49.800
indem du halt, also auf der Shell schreibe ich

02:10:49.800 --> 02:10:51.340
auf Time einfach davor, und dann

02:10:51.340 --> 02:10:53.580
kriege ich halt dann eine Ausgabe, wie viel

02:10:53.580 --> 02:10:56.220
wie lange das gedauert hat

02:10:56.220 --> 02:10:58.140
bei Jupyter-Notebook-Zellen.

02:10:58.280 --> 02:11:00.760
Das gibt es auch halt, irgendwie so ein Prozent-Time-Magie.

02:11:01.200 --> 02:11:02.100
Du kannst aber, wenn du

02:11:02.100 --> 02:11:03.900
jetzt einen Benchmark machen möchtest, dafür ist das natürlich

02:11:03.900 --> 02:11:06.020
nicht gut, das einmal auszuführen, oder zweimal,

02:11:06.320 --> 02:11:08.200
sondern da möchte man das halt ein paar Mal

02:11:08.200 --> 02:11:09.680
ausführen, sodass halt dann auch so

02:11:09.680 --> 02:11:11.600
Cache-Effekte und so nicht so eine Rolle spielen.

02:11:12.220 --> 02:11:13.020
Und da gibt es dann halt

02:11:13.020 --> 02:11:16.100
auch Prozent-Time-Magie,

02:11:16.100 --> 02:11:17.840
wo das dann halt 10.000 Mal ausgeführt wird,

02:11:18.000 --> 02:11:19.700
und dann wird dann halt Durchschnitt berechnet,

02:11:19.840 --> 02:11:22.040
und dann ist es okay, diese Funktion dauert irgendwie

02:11:22.040 --> 02:11:23.300
üblicherweise,

02:11:23.580 --> 02:11:25.060
1,7 Nanosekunden,

02:11:25.320 --> 02:11:28.020
1,7 Nanosekunden wäre schnell für die Funktion.

02:11:29.460 --> 02:11:30.540
Und dann weiß man halt,

02:11:30.640 --> 02:11:31.800
okay, wenn ich die jetzt so oft aufrufe,

02:11:31.940 --> 02:11:32.920
dann dauert das halt.

02:11:33.880 --> 02:11:33.940
Ja.

02:11:35.860 --> 02:11:36.260
Genau.

02:11:37.880 --> 02:11:39.760
Und ansonsten eben C-Profile

02:11:39.760 --> 02:11:41.460
kann man verwenden, wenn man es genau

02:11:41.460 --> 02:11:43.960
möchte, wenn man jetzt noch gar keine Ahnung hat, wo man nachgucken möchte,

02:11:44.300 --> 02:11:45.840
und dann rauskriegen möchte,

02:11:45.980 --> 02:11:47.820
welche Funktion wird eigentlich am häufigsten aufgerufen,

02:11:48.020 --> 02:11:49.240
und wie lange verbringt mein

02:11:49.240 --> 02:11:51.960
System sozusagen in welchen Funktionen,

02:11:52.780 --> 02:11:53.380
dann ist

02:11:53.580 --> 02:11:55.960
halt so ein Profile eine ganz hilfreiche

02:11:55.960 --> 02:11:57.840
Geschichte, und dann, wenn man weiß, wo man

02:11:57.840 --> 02:11:59.080
Zeit verbringt, dann kann man halt mit

02:11:59.080 --> 02:12:01.520
TimeIt zum Beispiel in der Notebook-Zelle

02:12:01.520 --> 02:12:03.720
halt dann irgendwie gucken, ob man das irgendwie optimiert

02:12:03.720 --> 02:12:05.920
kriegt, und dann kann man sozusagen die heißen

02:12:05.920 --> 02:12:07.780
Funktionen

02:12:07.780 --> 02:12:09.560
ein bisschen optimieren, und dann sollte das

02:12:09.560 --> 02:12:12.660
schneller werden.

02:12:13.660 --> 02:12:13.780
Ja.

02:12:14.740 --> 02:12:15.100
Ja.

02:12:15.760 --> 02:12:17.480
Ja, das war die letzte Frage, glaube ich, für heute.

02:12:17.600 --> 02:12:19.160
Ich glaube, wir sind tatsächlich irgendwie durch. Wir haben

02:12:19.160 --> 02:12:21.780
viel geredet über Python selbst.

02:12:22.260 --> 02:12:23.560
Ich hoffe, das fandet ihr wieder interessant.

02:12:23.580 --> 02:12:24.200
Genau.

02:12:24.820 --> 02:12:27.440
Ja, genau, haben wir noch irgendwie

02:12:27.440 --> 02:12:28.940
Pics oder sowas? Pic der Woche?

02:12:29.440 --> 02:12:29.640
Ja.

02:12:31.780 --> 02:12:32.900
Bis Monats!

02:12:35.160 --> 02:12:35.440
Ja.

02:12:36.840 --> 02:12:37.660
Also, ich hätte

02:12:37.660 --> 02:12:39.500
da noch was. Ja, was ist dein Pic

02:12:39.500 --> 02:12:40.460
der Monats?

02:12:42.640 --> 02:12:43.600
Und zwar,

02:12:43.820 --> 02:12:45.500
ich habe mich

02:12:45.500 --> 02:12:46.960
letztens wieder damit beschäftigt,

02:12:47.420 --> 02:12:48.600
mich nochmal aufzusetzen,

02:12:49.740 --> 02:12:51.560
und habe dann

02:12:51.560 --> 02:12:53.460
nochmal so irgendwie angeguckt, ob es nicht

02:12:53.580 --> 02:12:55.400
wie macht man das eigentlich vernünftige

02:12:55.400 --> 02:12:56.460
Python-Entwicklungsumgebung

02:12:56.460 --> 02:12:58.880
aufsetzen. Dazu gab es einen

02:12:58.880 --> 02:13:01.980
Artikel

02:13:01.980 --> 02:13:03.980
von Jacob Kaplan-Moss, glaube ich,

02:13:04.680 --> 02:13:05.520
einer der

02:13:05.520 --> 02:13:08.880
Django-Gründer

02:13:08.880 --> 02:13:09.120
da,

02:13:09.600 --> 02:13:11.120
hat dazu irgendwie meine

02:13:11.120 --> 02:13:13.340
Python-Entwicklungsumgebung 2020

02:13:13.340 --> 02:13:14.840
Edition oder so einen Artikel geschrieben,

02:13:14.980 --> 02:13:17.320
das sollte ich mal verlinken, und da dachte ich so, ah, gut,

02:13:17.460 --> 02:13:18.920
dann gucke ich doch mal, was der so macht, dann

02:13:18.920 --> 02:13:21.160
wie ich das so mache, und ob es da irgendwie

02:13:21.160 --> 02:13:23.440
und das, worauf ich da eine

02:13:23.440 --> 02:13:24.940
Geschichte, auf die ich da gestoßen bin, die ich vorher

02:13:24.940 --> 02:13:26.960
nicht so verwendet habe, weiß gar nicht genau, warum,

02:13:27.120 --> 02:13:29.100
ich habe schon davon gehört, mir haben Leute davon erzählt,

02:13:29.240 --> 02:13:31.360
aber habe es irgendwie nicht benutzt, ist PyEnv.

02:13:33.180 --> 02:13:35.200
Und das war so eine der Geschichten, die ich,

02:13:35.600 --> 02:13:37.380
also, genau, das wäre halt beim Tick, PyEnv,

02:13:38.080 --> 02:13:39.320
und das ist eigentlich

02:13:39.320 --> 02:13:40.500
ziemlich cool, weil

02:13:40.500 --> 02:13:43.520
das ist halt ein kleines

02:13:43.520 --> 02:13:46.780
Tool, was einem

02:13:46.780 --> 02:13:49.120
dabei hilft, halt Python zu installieren, was

02:13:49.120 --> 02:13:51.420
überraschend schwer ist, es sollte eigentlich nicht so schwer sein, aber es ist halt

02:13:51.420 --> 02:13:53.420
ein ganz schönes Adson,

02:13:53.440 --> 02:13:55.420
vor allen Dingen braucht man Python oft

02:13:55.420 --> 02:13:57.600
in sehr unterschiedlichen Versionen,

02:13:57.800 --> 02:13:59.420
unterschiedlichen Arten, wie man es

02:13:59.420 --> 02:14:01.460
installiert, so, für manche Projekte brauche

02:14:01.460 --> 02:14:03.220
ich halt Minikonda

02:14:03.220 --> 02:14:05.260
oder Conda, ja, so, und

02:14:05.260 --> 02:14:06.980
mache, benutze auch Conda zum

02:14:06.980 --> 02:14:09.380
Installieren von irgendwelchen Abhängigkeiten und so,

02:14:09.740 --> 02:14:11.080
und Paketen in anderen

02:14:11.080 --> 02:14:13.220
Webentwicklungsgeschichten wie der Virtual Envs,

02:14:13.440 --> 02:14:15.040
und da eher

02:14:15.040 --> 02:14:17.400
auch wieder einen anderen Python-Interpreter,

02:14:17.560 --> 02:14:19.420
jetzt möglicherweise halt einfach einen, der

02:14:19.420 --> 02:14:21.120
über Homebrew gekommen ist, oder

02:14:21.120 --> 02:14:23.320
den ich einfach so installiert habe, oder so,

02:14:23.320 --> 02:14:23.420
was,

02:14:23.440 --> 02:14:25.700
ja, und

02:14:25.700 --> 02:14:27.620
ja, also,

02:14:28.980 --> 02:14:31.260
das war immer so ein bisschen doof, und mit PyEnv ist das

02:14:31.260 --> 02:14:32.940
eigentlich relativ einfach, da sagt man dann halt,

02:14:33.060 --> 02:14:35.180
okay, ich hätte gern, also

02:14:35.180 --> 02:14:37.340
der installiert dann halt auch, PyEnv installiert

02:14:37.340 --> 02:14:38.480
halt auch Minikonda und sowas,

02:14:38.900 --> 02:14:41.200
und dann kann man halt sagen,

02:14:41.300 --> 02:14:43.240
okay, PyEnv install Minikonda

02:14:43.240 --> 02:14:44.580
latest, und dann hat man halt die,

02:14:45.280 --> 02:14:47.100
muss man nicht mehr sich damit beschäftigen, da

02:14:47.100 --> 02:14:48.020
irgendwie dieses Shell-Skript,

02:14:48.360 --> 02:14:51.260
irgendwie Curl in irgendwie Shell-Skript

02:14:51.260 --> 02:14:53.180
zu pipen, und dann Minikonda

02:14:53.180 --> 02:14:55.100
zu installieren, sondern es passiert alles

02:14:55.100 --> 02:14:56.340
für einen automatisch,

02:14:57.160 --> 02:14:57.620
und

02:14:57.620 --> 02:15:01.080
man kann halt auch pro Verzeichnis dann definieren,

02:15:01.200 --> 02:15:03.200
was denn jetzt der Interpreter ist,

02:15:03.260 --> 02:15:05.040
der ausgeführt werden soll, wenn man jetzt da Python

02:15:05.040 --> 02:15:07.180
eingibt. Also gibt es dann so einen Punkt

02:15:07.180 --> 02:15:09.180
Python-Version-File, und da steht

02:15:09.180 --> 02:15:10.800
das dann halt einfach drin, und das kann halt

02:15:10.800 --> 02:15:13.220
auch ein Name

02:15:13.220 --> 02:15:15.200
von einem Virtual Env sein, dann ist man halt in diesem

02:15:15.200 --> 02:15:17.240
Virtual Env, oder

02:15:17.240 --> 02:15:18.940
es kann halt der Name sein von einem Conda-Environment,

02:15:19.040 --> 02:15:20.760
und das ist halt

02:15:20.760 --> 02:15:23.040
sehr, sehr cool, das heißt, ich hatte

02:15:23.040 --> 02:15:24.760
vorher sonst immer ein MK,

02:15:25.000 --> 02:15:26.900
also Virtual Env-Wrapper verwendet,

02:15:26.960 --> 02:15:29.300
und dann immer so Post-Activate-Skripten,

02:15:29.380 --> 02:15:32.220
einmal

02:15:32.220 --> 02:15:34.340
dann halt,

02:15:35.920 --> 02:15:37.120
achso, ne, ich überlege gerade,

02:15:37.160 --> 02:15:38.560
ob das nicht ein anderes Thema ist, aber ne,

02:15:40.660 --> 02:15:41.220
ins Verzeichnis

02:15:41.220 --> 02:15:42.660
gewechselt, dann noch so Dinge gemacht und so,

02:15:42.840 --> 02:15:44.920
und das geht eigentlich quasi mittlerweile

02:15:44.920 --> 02:15:46.980
alles relativ automatisch, und man muss halt auch nicht

02:15:46.980 --> 02:15:47.240
mehr

02:15:47.240 --> 02:15:50.900
Work-On irgendwas sagen, sondern dann geht einfach

02:15:50.900 --> 02:15:52.860
in das Verzeichnis, und dann ist gut.

02:15:53.040 --> 02:15:54.680
Also es funktioniert noch nicht alles hundertprozentig,

02:15:54.940 --> 02:15:56.420
das ist auch noch so eine Idee. Ich glaube,

02:15:56.560 --> 02:15:59.240
ich packe das irgendwo, wo packe ich denn das am besten hin?

02:15:59.540 --> 02:16:00.860
Ich habe mir das mal versucht, irgendwann

02:16:00.860 --> 02:16:02.540
aufzuschreiben, sozusagen, was ich da alles tue,

02:16:03.420 --> 02:16:04.920
und was man so an

02:16:04.920 --> 02:16:07.200
hilfreichen Tools da verwenden kann,

02:16:07.500 --> 02:16:08.840
vielleicht packe ich das irgendwo auf GitHub

02:16:08.840 --> 02:16:09.740
in Gist oder so,

02:16:10.580 --> 02:16:13.080
vielleicht haben andere Leute da ja auch noch Ideen, was man da an tollen

02:16:13.080 --> 02:16:14.920
Dingen machen kann, und vor allem, manche Sachen

02:16:14.920 --> 02:16:16.960
funktionieren auch nicht so ganz sauber, also von

02:16:16.960 --> 02:16:18.900
irgendwie Virtual Env nach Conda

02:16:18.900 --> 02:16:20.880
wechseln, das geht irgendwie, aber umgekehrt geht irgendwie nicht,

02:16:20.880 --> 02:16:22.260
oder so, weiß nicht genau, warum.

02:16:23.040 --> 02:16:25.400
Ja, und

02:16:25.400 --> 02:16:27.120
vielleicht wäre das mal eine sinnvolle Geschichte,

02:16:27.220 --> 02:16:29.000
das mal zusammenzutragen, was muss man eigentlich machen,

02:16:29.100 --> 02:16:30.880
um halt eine ordentliche Python-Entwicklungsumgebung

02:16:30.880 --> 02:16:32.340
irgendwie aufzusetzen.

02:16:32.380 --> 02:16:34.540
Ja, das geht auf jeden Fall nach einer guten Sache.

02:16:35.200 --> 02:16:35.420
Genau.

02:16:37.540 --> 02:16:38.420
Und genau,

02:16:38.500 --> 02:16:40.880
fand ich jetzt sehr, sehr

02:16:40.880 --> 02:16:42.460
überzeugend eigentlich, und

02:16:42.460 --> 02:16:43.920
bin ich eigentlich

02:16:43.920 --> 02:16:46.760
dachte ich mir, warum fände ich das jetzt eigentlich

02:16:46.760 --> 02:16:48.660
nicht schon immer, sozusagen, weil das

02:16:48.660 --> 02:16:50.720
vereinfacht doch eine Menge Sachen deutlich.

02:16:51.940 --> 02:16:52.680
Ja, ich habe auch einen

02:16:52.680 --> 02:16:54.320
kleinen Pick der Woche, also ich nehme diesmal

02:16:54.320 --> 02:16:56.600
Türkel, diese kleine Bibliothek, mit der man

02:16:56.600 --> 02:16:58.300
kleine Sachen zeichnen kann auf einer

02:16:58.300 --> 02:17:00.240
Kennung. Ach, so eine Grafik, ja. Ja, weil da kann man tatsächlich

02:17:00.240 --> 02:17:02.400
ganz lustige Sachen damit machen, zum Beispiel Kunst,

02:17:02.560 --> 02:17:05.040
man kann sich Algorithmen in den Mandelbrotmengen

02:17:05.040 --> 02:17:06.900
berechnen lassen, Funktionen, und der zeichnet dann ganz

02:17:06.900 --> 02:17:09.160
tolle, witzige Bilder, mit denen

02:17:09.160 --> 02:17:10.420
man Computerkunst macht.

02:17:11.120 --> 02:17:13.080
Also, unabhängig davon, dass man jetzt einen kleinen

02:17:13.080 --> 02:17:15.120
Schildkröte über den Bildschirm bewegen kann, um einfache

02:17:15.120 --> 02:17:17.100
grafische Spielchen zu bauen. Das fand ich

02:17:17.100 --> 02:17:19.040
sehr witzig, deswegen wollte ich das nochmal picken.

02:17:19.900 --> 02:17:21.000
Ja, cool, cool, cool.

02:17:21.760 --> 02:17:22.660
Ja, vielen Dank,

02:17:22.680 --> 02:17:24.760
fürs Zuhören. Egal wann ihr hört,

02:17:25.260 --> 02:17:26.900
Montags, Mittags, Abends,

02:17:26.980 --> 02:17:29.040
Nachts, bleibt uns gebogen, habt viel Spaß

02:17:29.040 --> 02:17:30.380
und wir hören uns bald wieder.

02:17:30.540 --> 02:17:32.020
Ja, bis zum nächsten Mal. Tschüss.

02:17:37.060 --> 02:17:39.060
Musik

02:17:41.040 --> 02:17:41.060
Musik

02:17:41.060 --> 02:17:41.060


02:17:41.060 --> 02:17:47.060
Musik

02:17:49.140 --> 02:17:49.160
Musik

02:17:49.160 --> 02:17:51.060
Musik

02:17:52.680 --> 02:17:54.100
Musik

02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:17:54.100


02:17:54.100 --> 02:18:11.140
Musik

02:18:11.140 --> 02:18:11.140


02:18:11.140 --> 02:18:13.200
Musik

02:18:13.200 --> 02:18:17.260
Musik

02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:17.260 --> 02:18:17.260


02:18:22.680 --> 02:18:37.020
Auf Takt

02:18:37.020 --> 02:18:41.040
Im Takt

02:18:41.040 --> 02:18:44.600
Im Viertakt

02:18:44.600 --> 02:18:47.620
Soll es klingen

02:18:47.620 --> 02:18:52.660
Drei kleine Dimensionen

02:18:52.680 --> 02:18:54.960
So Taktvoll

02:18:54.960 --> 02:18:58.680
Lichtspiel

02:18:58.680 --> 02:19:00.680
Impressionen

02:19:01.200 --> 02:19:02.180
So Farbvoll

02:19:02.180 --> 02:19:05.820
Farbton

02:19:05.820 --> 02:19:09.560
Halbton

02:19:09.560 --> 02:19:13.140
Und Synchron

02:19:13.140 --> 02:19:16.980
Dazu schwingen

02:19:16.980 --> 02:19:22.660
Drei kleine Dimensionen

02:19:22.680 --> 02:19:23.860
So Taktvoll

02:19:23.860 --> 02:19:27.540
Lichtspiel

02:19:27.540 --> 02:19:28.680
Impressionen

02:19:29.420 --> 02:19:30.680
So Farbvoll

02:19:31.200 --> 02:19:45.660
Wohlglang

02:19:45.660 --> 02:19:48.680
Delusionen

02:19:48.680 --> 02:19:49.360
Delusionen

02:19:49.360 --> 02:19:52.680
Die Unkontrollen

02:19:53.040 --> 02:19:54.100
Von Zwu起

02:19:54.100 --> 02:19:55.680
Von Zwu

02:19:55.680 --> 02:19:58.680
Von Zwu

02:19:58.680 --> 02:19:59.760
Von Zwu

02:19:59.760 --> 02:20:02.700
Von Zwu

02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:02.700


02:20:02.700 --> 02:20:03.600
So taktvoll.

02:20:06.060 --> 02:20:09.360
Licht spielt Impressionen.

02:20:09.360 --> 02:20:10.860
So farbvoll.

02:20:13.020 --> 02:20:14.340
Klänge.

02:20:16.600 --> 02:20:17.860
Zu Millionen.

02:20:20.460 --> 02:20:21.580
Überwinden.

02:20:23.840 --> 02:20:25.300
Die Distanzen.

02:20:28.320 --> 02:20:30.820
Dreiklangs Dimensionen.

02:20:31.720 --> 02:20:32.500
So taktvoll.

02:20:32.700 --> 02:20:37.700
Licht spielt Impressionen.

02:20:38.580 --> 02:20:39.780
So farbvoll.

02:21:02.700 --> 02:21:04.700
Klänge.

02:21:04.700 --> 02:21:32.680
So taktvoll.

02:21:32.700 --> 02:22:02.680
Dreiklangs Dimensionen.

02:22:02.700 --> 02:22:04.700
So taktvoll.

02:22:04.700 --> 02:22:06.460
Ausgang.

02:22:09.020 --> 02:22:10.020
Abgang.

02:22:12.800 --> 02:22:13.820
Sequenzen.

02:22:16.240 --> 02:22:16.700
Ohne Grenzen.

02:22:20.240 --> 02:22:22.700
Dreiklangs Dimensionen.

02:22:23.460 --> 02:22:24.460
So taktvoll.

02:22:27.300 --> 02:22:28.700
Licht spielt Impressionen.

02:22:30.700 --> 02:22:31.620
So farbvoll.

02:22:32.700 --> 02:22:35.700
Dreiklangs Dimensionen.

02:22:35.700 --> 02:22:38.700
So taktvoll.

02:22:38.700 --> 02:22:45.700
Licht spielt Impressionen.

02:22:45.700 --> 02:22:45.700


02:22:45.700 --> 02:22:50.720
Dreiklangs Dimensionen.

02:22:50.720 --> 02:22:53.220
So taktvoll.

02:22:53.220 --> 02:22:55.920
Licht spielt Impressionen.

02:22:55.920 --> 02:22:57.280
So farbvoll.

02:22:57.280 --> 02:22:57.900
Dreiklangs Dimensionen.

02:22:57.900 --> 02:22:58.380
So taktvoll.

02:22:58.380 --> 02:22:58.380


02:22:58.380 --> 02:22:58.820
So farbvoll.

02:22:58.820 --> 02:22:59.220
Dreiklangs Dimensionen.

02:22:59.220 --> 02:23:00.160
So taktvoll.

02:23:00.160 --> 02:23:00.660
Licht spielt Impressionen.

02:23:00.660 --> 02:23:01.020
So farbvoll.

02:23:01.020 --> 02:23:01.700
Dreiklangs Dimensionen.

02:23:01.700 --> 02:23:02.060
So taktvoll.

02:23:02.060 --> 02:23:02.400
Dreiklangs Dimensionen.

02:23:02.400 --> 02:23:07.740
Drei Glanzdimensionen, so taktvoll.

02:23:09.540 --> 02:23:14.920
Licht spielt Impressionen, so farbvoll.

02:23:16.760 --> 02:23:22.180
Drei Glanzdimensionen, so taktvoll.

02:23:24.320 --> 02:23:29.380
Licht spielt Impressionen, so farbvoll.

02:23:32.400 --> 02:23:36.600
Drei Glanzdimensionen, so taktvoll.