WEBVTT

00:00:00.500 --> 00:00:04.540
Ja, hallo liebe Hörerinnen und Hörer. Willkommen bei einem 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.040 --> 00:00:08.400
Hallihallo.

00:00:09.100 --> 00:00:10.600
Diesmal scheint sogar noch die Sonne zu sein. Wahnsinn.

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

00:00:16.680 --> 00:00:18.020
Ja, wir haben tatsächlich Dezember irgendwie.

00:00:18.940 --> 00:00:23.540
Ja, der 12. Dezember, genau. Vielleicht gar nicht so schlecht, wenn wir das mal dazusagen, wann das ist.

00:00:23.820 --> 00:00:26.620
Ja, wir haben uns ein bisschen Zeit gelassen in letzter Zeit mit den Folgen, es war so viel zu tun,

00:00:26.620 --> 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:37.080
Ja, genau. Das ist aber die Frage, was man da empfindet, wenn man das hört.

00:00:37.320 --> 00:00:39.800
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.980 --> 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.380 --> 00:00:53.480
Worum es eigentlich bei Python geht. Ein paar ganz grundlegende Sachen.

00:00:53.780 --> 00:00:54.820
Vielleicht wird es ja spannend.

00:00:55.560 --> 00:00:57.600
Also, ja, keine Lava-Folge, kennt ihr schon.

00:00:58.620 --> 00:00:59.480
Wen ihr schon gehört habt.

00:00:59.840 --> 00:01:00.280
Ja, ja.

00:01:01.400 --> 00:01:03.360
Genau, das mit den Themen können wir auch

00:01:03.360 --> 00:01:04.000
irgendwann mal klassen.

00:01:04.140 --> 00:01:06.360
Die nächste Lava-Folge.

00:01:06.620 --> 00:01:08.900
Ja, was machen wir hier eigentlich heute?

00:01:09.180 --> 00:01:10.920
Und was ist so passiert in der Szene?

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

00:01:12.900 --> 00:01:14.900
Nee, nicht, dass ich, ich glaube,

00:01:14.940 --> 00:01:16.620
seit dem letzten Mal hat sich da gar nicht so viel getan.

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

00:01:18.140 --> 00:01:19.560
Oh ja, doch, ja, richtig, du hast recht.

00:01:20.120 --> 00:01:23.480
Ja, tatsächlich, Django 3 ist raus

00:01:23.480 --> 00:01:25.580
und das war, das ist natürlich eine tolle Geschichte.

00:01:26.280 --> 00:01:27.160
Ich habe das direkt mal versucht

00:01:27.160 --> 00:01:29.360
zu installieren und da so ein paar Sachen

00:01:29.360 --> 00:01:30.920
irgendwie mitzumachen, aber

00:01:30.920 --> 00:01:33.560
habe dann feststellen müssen,

00:01:33.680 --> 00:01:35.660
dass ein Haufen der Abhängigkeiten, die man so defaultmäßig

00:01:35.660 --> 00:01:37.240
irgendwie in Django-Projekten drin hat,

00:01:38.200 --> 00:01:39.660
dann nicht mehr so richtig

00:01:39.660 --> 00:01:41.540
funktioniert haben, beziehungsweise dazu führen, dass man

00:01:41.540 --> 00:01:43.360
halt ein Traceback kriegt, wenn man was für den Entwicklungsserver

00:01:43.360 --> 00:01:45.220
zu starten und

00:01:45.220 --> 00:01:47.620
ja, unter anderem sowas wie

00:01:47.620 --> 00:01:49.560
Django-Model-Utils, was

00:01:49.560 --> 00:01:51.600
irgendwie fast alle Leute, also ich verwende

00:01:51.600 --> 00:01:53.720
das eigentlich immer. Wahrscheinlich auch eine Menge andere Leute

00:01:53.720 --> 00:01:55.700
wegen

00:01:55.700 --> 00:01:57.660
Timestamp-Model oder so, was man ja

00:01:57.660 --> 00:01:58.280
oft verwendet.

00:02:00.620 --> 00:02:01.560
Ich weiß nicht mehr genau,

00:02:01.600 --> 00:02:02.300
was es noch alles war.

00:02:03.140 --> 00:02:05.480
Ich habe dann für die Sachen, die

00:02:05.480 --> 00:02:07.280
nicht funktioniert haben, da habe ich dann

00:02:07.280 --> 00:02:09.080
einfach die geforkt auf GitHub

00:02:09.080 --> 00:02:10.520
und

00:02:10.520 --> 00:02:13.360
habe das dann versucht zu fixen und dann halt

00:02:13.360 --> 00:02:15.140
entsprechend immer Pull-Requests aufgemacht.

00:02:16.720 --> 00:02:17.600
Also das heißt, ihr könntet bei Jochen

00:02:17.600 --> 00:02:19.500
in den Repos versuchen, die auch bei

00:02:19.500 --> 00:02:20.540
Dango 3 funktionieren?

00:02:21.400 --> 00:02:23.180
Nein, nee, das sollte man vielleicht

00:02:23.180 --> 00:02:23.840
nicht machen, also

00:02:23.840 --> 00:02:27.200
Daran wird sich das irgendwie

00:02:27.200 --> 00:02:28.560
mitten oder so, nee, nee, nee

00:02:28.560 --> 00:02:31.100
Aber es hat mich gewundert, wie viel da noch

00:02:31.100 --> 00:02:33.200
nicht funktioniert hat, also es war bei so einem

00:02:33.200 --> 00:02:35.200
normalen, ich weiß nicht, bei welchem

00:02:35.200 --> 00:02:37.020
ich das probiert habe, entweder bei einer Webseite oder

00:02:37.020 --> 00:02:38.380
auch bei der Python-Podcast

00:02:38.380 --> 00:02:41.280
Projekt-Dings

00:02:41.280 --> 00:02:43.000
habe ich mal versucht, das auf Django 3

00:02:43.000 --> 00:02:44.940
umzustellen und das ist

00:02:44.940 --> 00:02:46.220
mit fünf

00:02:46.220 --> 00:02:49.020
Einhängigkeiten oder so sind kaputt gegangen

00:02:49.020 --> 00:02:51.300
und ich glaube, ich habe auch so fünf Pull-Requests

00:02:51.300 --> 00:02:53.260
irgendwie gemacht. Also bei Danko gibt es irgendwie

00:02:53.260 --> 00:02:54.980
immer drei oder vier Versionen, oder nee, drei.

00:02:55.120 --> 00:02:56.980
Also 0, 1 und 2 und dann ist

00:02:56.980 --> 00:02:59.180
nämlich das Major Release. War das nochmal was?

00:02:59.240 --> 00:03:01.180
Also ich glaube 0 ist immer so die neue

00:03:01.180 --> 00:03:03.200
Feature-Sachen? Nee, ist immer

00:03:03.200 --> 00:03:05.260
gerade, ungerade. Gerade

00:03:05.260 --> 00:03:07.100
sind immer die Long-Term. Ich glaube

00:03:07.100 --> 00:03:09.080
2 ist Long-Term. Punkt 2.

00:03:09.200 --> 00:03:11.300
Also 2.2, 1.2, 3.2

00:03:11.300 --> 00:03:13.180
sind die Long-Term.

00:03:13.180 --> 00:03:14.980
Und 1...

00:03:14.980 --> 00:03:17.300
Ich bin mir sicher. Okay, gut, sehr gut.

00:03:17.540 --> 00:03:19.160
Und 1 ist irgendwas anderes, das weiß ich

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

00:03:21.240 --> 00:03:23.480
was man dann macht? Also für Security-Patches dann wahrscheinlich

00:03:23.480 --> 00:03:25.460
mal die Zweier-Version nehmen, dass man irgendwie stabil sein möchte?

00:03:25.900 --> 00:03:27.740
Nee, also das, was tatsächlich

00:03:27.740 --> 00:03:29.680
empfohlen wird eigentlich,

00:03:29.840 --> 00:03:31.340
also das ist auch so eine Legacy-Geschichte,

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

00:03:34.660 --> 00:03:34.840
Und

00:03:34.840 --> 00:03:36.800
naja, jedenfalls sagt das

00:03:36.800 --> 00:03:39.440
derjenige, der aktuell irgendwie

00:03:39.440 --> 00:03:41.440
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:48.640
und das machen eigentlich alle

00:03:48.640 --> 00:03:51.120
Leute, die

00:03:51.120 --> 00:03:52.940
da wirklich viel Ahnung

00:03:52.940 --> 00:03:54.860
von haben, dass man halt, also

00:03:54.860 --> 00:03:56.840
früher war das wohl mal anders, aber mittlerweile sind

00:03:56.840 --> 00:03:58.580
die neuen Versionen von Django so stabil

00:03:58.580 --> 00:04:00.840
und so gut getestet, dass man eigentlich

00:04:00.840 --> 00:04:02.380
immer möglichst nah dran an

00:04:02.380 --> 00:04:03.960
der Entwicklung bleiben sollte.

00:04:04.640 --> 00:04:06.540
Weil es auch gar nicht mehr so schlimm ist, bis dahin

00:04:06.540 --> 00:04:08.880
abzudaten. Es geht gar

00:04:08.880 --> 00:04:10.260
nicht mehr so viel kaputt. Sollte eigentlich nicht.

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

00:04:12.900 --> 00:04:14.700
Also eigentlich, weil das halt

00:04:14.700 --> 00:04:16.660
macht halt viele andere Sachen deutlich einfacher, wenn man

00:04:16.660 --> 00:04:18.440
das so rummacht. Und wenn man halt

00:04:18.440 --> 00:04:20.620
auf der Long-Term-Support-Version sitzt, dann

00:04:20.620 --> 00:04:22.520
ja, hat man halt irgendwann

00:04:22.520 --> 00:04:24.580
ein großes Problem und das

00:04:24.580 --> 00:04:25.840
will man vielleicht dann doch nicht. Also

00:04:25.840 --> 00:04:28.580
die Art, wie man das heute macht, aber auf der anderen Seite machen das

00:04:28.580 --> 00:04:30.180
viele Leute schon seit langer Zeit so.

00:04:30.640 --> 00:04:32.540
Insofern kann man, die kann man auch nicht einfach alle so vor den Kopf

00:04:32.540 --> 00:04:33.280
stoßen, aber

00:04:33.280 --> 00:04:36.480
so wie man das heute eigentlich machen

00:04:36.480 --> 00:04:38.460
sollte, ist eigentlich immer die aktuellste

00:04:38.460 --> 00:04:39.240
Django-Version verwenden.

00:04:40.160 --> 00:04:42.380
Okay. Und ich

00:04:42.380 --> 00:04:44.440
versuche das auch immer und normalerweise funktioniert, also bis jetzt

00:04:44.440 --> 00:04:46.460
auch die 2er-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.280 --> 00:04:53.000
Und das war auch in allen Fällen das gleiche Problem.

00:04:53.140 --> 00:04:55.360
Und zwar sind halt so ein paar private APIs

00:04:55.360 --> 00:04:58.500
für die Unterstützung von so alten Python-2-Geschichten

00:04:58.500 --> 00:05:00.220
sind jetzt aus Django 3 rausgeflogen.

00:05:00.360 --> 00:05:03.020
Also eigentlich 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:04.780
Oh, das läuft ja aus.

00:05:04.860 --> 00:05:06.680
Wir können ja runterzählen, es sind nur noch Tage.

00:05:06.740 --> 00:05:09.480
Ja, es sind nur noch Tage, bis es irgendwie vorbei ist.

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

00:05:11.080 --> 00:05:11.340
Ja.

00:05:11.520 --> 00:05:11.680
Ja.

00:05:13.080 --> 00:05:16.300
Aber es waren noch so ein paar

00:05:16.300 --> 00:05:18.400
Geschichten dabei,

00:05:18.600 --> 00:05:20.140
so zum Beispiel, man konnte irgendwas, es gab so einen

00:05:20.140 --> 00:05:23.100
Dekorator-Pi2-Unicode-String

00:05:23.100 --> 00:05:24.720
oder sowas, den man über Funktionen

00:05:24.720 --> 00:05:26.140
setzen konnte und dann kam das halt mit

00:05:26.140 --> 00:05:27.800
auch den alten

00:05:27.800 --> 00:05:30.680
Geschichten klar und

00:05:30.680 --> 00:05:32.120
Six gab es halt auch

00:05:32.120 --> 00:05:33.640
in Django drin.

00:05:34.040 --> 00:05:36.520
Was auch immer Six ist. Ja, auch so eine Geschichte, die einem

00:05:36.520 --> 00:05:38.400
helfen soll, damit

00:05:38.400 --> 00:05:40.200
umzugehen, wenn es halt

00:05:40.200 --> 00:05:42.700
ja, Python 2

00:05:42.700 --> 00:05:44.120
und Python 3 Geschichten sind.

00:05:44.160 --> 00:05:46.480
Ich unterbreche dich gerade ungenau. Wir haben eigentlich versprochen,

00:05:46.600 --> 00:05:47.860
dass es eine Anfängerfolge 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.980 --> 00:05:52.380
Nee, das ist eigentlich auch nicht so.

00:05:52.460 --> 00:05:54.800
Es sind ein paar Hilfsfunktionen,

00:05:54.840 --> 00:05:57.440
die einem dabei helfen, das für Python 2

00:05:57.440 --> 00:05:58.820
und Python 3 gleichzeitig zu machen.

00:05:59.740 --> 00:06:00.660
Die sind jetzt tatsächlich

00:06:00.660 --> 00:06:02.620
entfernt worden. Die waren vorher bloß deprecated,

00:06:02.740 --> 00:06:04.060
aber jetzt sind die halt wirklich weg.

00:06:04.900 --> 00:06:06.720
Und das heißt, wenn jemand die noch

00:06:06.720 --> 00:06:08.700
verwendet, ein Paket, die noch verwendet,

00:06:08.820 --> 00:06:10.780
dann gibt es halt ein Traceback an der Stelle.

00:06:10.780 --> 00:06:12.480
Also alles, was jetzt in Python 3 deprecated

00:06:12.480 --> 00:06:14.100
angezeigt wird, ist bei Python 4 dann weg.

00:06:14.360 --> 00:06:16.840
Bei Python, sag ich schon. Bei Django 3, 4.

00:06:17.060 --> 00:06:18.540
Ja, also diese

00:06:18.540 --> 00:06:20.620
Geschichten waren jetzt halt dann

00:06:20.620 --> 00:06:22.240
weg. Und das hat

00:06:22.240 --> 00:06:24.620
dann auch diverse Pakete gebrochen

00:06:24.620 --> 00:06:25.940
und insofern, ja, also

00:06:25.940 --> 00:06:28.620
Umstieg auf Django 3 nicht so super easy.

00:06:28.860 --> 00:06:30.460
Wie lange ist es, bis Django 2 rauskam?

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

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

00:06:36.780 --> 00:06:38.380
Ich würde mal so tippen. Ages.

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

00:06:40.780 --> 00:06:42.220
irgendwas um die zwei Jahre ein bisschen?

00:06:42.460 --> 00:06:44.440
Das geht ja. Ja, also die

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

00:06:47.040 --> 00:06:50.380
das war früher alles viel länger und

00:06:50.380 --> 00:06:52.740
ja, Django 2 gab es

00:06:52.740 --> 00:06:54.580
jetzt gar nicht so lang. Ja, wenn du noch

00:06:54.580 --> 00:06:56.460
welche News einst, weil sonst machen wir tatsächlich weiter mit

00:06:56.460 --> 00:06:58.640
Content heute. Ja, ne, Content

00:06:58.640 --> 00:07:00.520
klingt gut. Also ich stelle

00:07:00.520 --> 00:07:02.760
jetzt immer ein paar blöde Fragen

00:07:02.760 --> 00:07:05.840
und ich

00:07:05.840 --> 00:07:08.460
versuche dich dazu zu bringen, dass du die Fragen möglichst

00:07:08.460 --> 00:07:09.600
kurz beantwortest.

00:07:10.420 --> 00:07:12.660
Oder so eine Minute pro Fage oder so.

00:07:13.060 --> 00:07:13.680
Vielleicht schaffen wir das.

00:07:13.800 --> 00:07:14.260
Wow, okay.

00:07:14.920 --> 00:07:15.420
Ja, alles klar.

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

00:07:18.220 --> 00:07:19.180
Das ist natürlich auch was anderes.

00:07:19.360 --> 00:07:20.740
Aber mal gucken.

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

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

00:07:23.140 --> 00:07:24.100
Ist Python eine Schlange?

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

00:07:28.000 --> 00:07:31.980
Also, nee, tatsächlich ist das eine Referenz auf Monty Python.

00:07:33.300 --> 00:07:35.380
Spam, Spam, Spam, Spam, Spam, Spam.

00:07:35.380 --> 00:07:36.280
Genau, genau.

00:07:36.760 --> 00:07:38.600
auch interessant,

00:07:38.600 --> 00:07:38.980
der

00:07:38.980 --> 00:07:42.400
Monty Pythons

00:07:42.400 --> 00:07:43.440
Flying Circus, also

00:07:43.440 --> 00:07:46.460
der Flying Circus ist wiederum

00:07:46.460 --> 00:07:48.220
eine Anspielung auf, glaube ich,

00:07:48.600 --> 00:07:50.180
Ersten Weltkrieg, Roter Brunnen,

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

00:07:53.520 --> 00:07:54.480
Die nannte man

00:07:54.480 --> 00:07:56.140
halt, das war halt so die

00:07:56.140 --> 00:07:58.440
informelle Bezeichnung,

00:07:58.660 --> 00:08:00.580
weil die halt immer mit Zelten auf irgendwelchen

00:08:00.580 --> 00:08:02.300
Äckern und Wiesen unterwegs waren,

00:08:02.580 --> 00:08:04.480
weil es sowas wie Flugplätze ja damals noch gar

00:08:04.480 --> 00:08:06.460
nicht gab, wurden die dann halt auch mal

00:08:06.760 --> 00:08:08.460
der fliegende Zirkus genannt und

00:08:08.460 --> 00:08:10.440
ja,

00:08:10.760 --> 00:08:12.940
ja, aber wo

00:08:12.940 --> 00:08:14.400
Monty Python eigentlich herkommt,

00:08:15.260 --> 00:08:16.840
weiß ich jetzt auch nicht. Also Guido hat sich das dann ja irgendwie

00:08:16.840 --> 00:08:17.900
so ausgedacht. Genau, also

00:08:17.900 --> 00:08:20.140
die Referenz

00:08:20.140 --> 00:08:22.100
des Namens der Programmiersprache

00:08:22.100 --> 00:08:24.320
bezieht sich schon auf Monty Python.

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

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

00:08:28.420 --> 00:08:30.040
und es ist ja sogar im Logo mittlerweile drin.

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

00:08:33.140 --> 00:08:34.100
Wenn ich mir ganz viele

00:08:34.100 --> 00:08:36.480
Python-Muster auf mein Körper

00:08:36.480 --> 00:08:38.500
tätowieren lasse, dann ist das natürlich ein Zeichen von meiner

00:08:38.500 --> 00:08:39.620
Liebe zur Sprache.

00:08:41.280 --> 00:08:42.600
Tja. Ja, man kann sich ja schlecht nur

00:08:42.600 --> 00:08:44.440
irgendwelche Gags 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.500 --> 00:08:49.860
So. So, so. Ja.

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

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

00:08:55.520 --> 00:08:56.240
Nächste Frage wäre,

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

00:09:01.500 --> 00:09:02.460
Na ja, schon eine ganze Menge,

00:09:02.580 --> 00:09:04.520
aber ich würde sagen, die allerwichtigsten zur Zeit

00:09:04.520 --> 00:09:06.360
sind, ja,

00:09:06.480 --> 00:09:08.440
Data Science ist jetzt, glaube ich, das

00:09:08.440 --> 00:09:10.360
am stärksten 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.420
Einfach deswegen, weil das halt

00:09:14.420 --> 00:09:16.340
irgendwie alle machen wollen, weil da auch viele

00:09:16.340 --> 00:09:17.880
Fortschritte passieren und Python ist halt

00:09:17.880 --> 00:09:18.960
die

00:09:18.960 --> 00:09:22.600
Programmiersprache, mit der man das vielleicht am besten machen kann,

00:09:22.700 --> 00:09:24.340
abgesehen von R. Aber R ist halt

00:09:24.340 --> 00:09:26.360
ein bisschen, hat ein bisschen einen engeren Einsatzzweck

00:09:26.360 --> 00:09:27.920
und du kannst halt nicht gut

00:09:27.920 --> 00:09:29.820
Webgeschichten zum Beispiel nachschreiben oder so.

00:09:29.900 --> 00:09:32.180
Oder ganze komplette Systeme in R bauen, das geht eigentlich

00:09:32.180 --> 00:09:34.180
nicht gut. Aber mit Python geht das, daher ist

00:09:34.180 --> 00:09:36.240
Python irgendwie da

00:09:36.240 --> 00:09:38.180
schon so, gerade für produktive

00:09:38.180 --> 00:09:39.340
Geschichten, das Mittel der Wahl.

00:09:40.100 --> 00:09:42.160
Also wenn man jetzt nicht nur Sachen analysieren möchte

00:09:42.160 --> 00:09:44.180
oder explorative Analyse von irgendwas

00:09:44.180 --> 00:09:46.300
machen möchte, sondern man möchte es tatsächlich einsetzen, dann

00:09:46.300 --> 00:09:48.260
kommt man eigentlich um Python nicht wirklich

00:09:48.260 --> 00:09:50.260
drumherum. Es gibt ja auch noch so ein paar Leute, die dann

00:09:50.260 --> 00:09:52.280
irgendwie, oder sagen wir so, das ist auch ein großer

00:09:52.280 --> 00:09:54.080
Bereich, aber die dann Java oder so verwenden.

00:09:54.360 --> 00:09:56.280
Es gibt ja auch irgendwie mit Scala,

00:09:56.640 --> 00:09:58.280
also nicht Java, sondern die Java4M

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

00:10:00.400 --> 00:10:01.700
obendrauf

00:10:01.700 --> 00:10:04.240
und Spark und da gibt es auch so DataFrames.

00:10:05.700 --> 00:10:06.020
Aber

00:10:06.020 --> 00:10:09.620
ich würde sagen, das ist ein deutliches Stück kleiner

00:10:09.620 --> 00:10:11.640
als der

00:10:11.640 --> 00:10:12.320
PyData-Stack.

00:10:14.160 --> 00:10:15.540
Ja, also das ist auf jeden Fall

00:10:15.540 --> 00:10:17.380
das größte

00:10:17.380 --> 00:10:19.340
Thema, glaube ich, momentan, aber Web-Entwicklung

00:10:19.340 --> 00:10:20.440
ist nach wie vor auch sehr groß.

00:10:21.740 --> 00:10:23.060
Dann eine Geschichte, die

00:10:23.060 --> 00:10:24.980
jetzt kommt irgendwie,

00:10:26.720 --> 00:10:27.660
da wollen wir auch unbedingt

00:10:27.660 --> 00:10:28.500
nochmal was zu machen,

00:10:29.220 --> 00:10:31.580
ist alles, was irgendwie so mit Home-Automation

00:10:31.580 --> 00:10:33.220
Zeugs zu tun hat. Home Assistant

00:10:33.220 --> 00:10:35.600
ist ein

00:10:35.600 --> 00:10:37.680
großes Thema. Ich habe da letztens

00:10:37.680 --> 00:10:39.820
so um Weihnachten rum, dann kann ich auch noch mal

00:10:39.820 --> 00:10:41.320
gucken, ob diese ganzen Geschichten noch

00:10:41.320 --> 00:10:43.760
gehen oder Geschenke in bestimmte Richtungen

00:10:43.760 --> 00:10:45.820
werfen, die irgendwas in der Art

00:10:45.820 --> 00:10:47.700
tun, weil das ja doch eine ganz angenehme

00:10:47.700 --> 00:10:49.600
Sache ist, wenn man halt Lampen und sowas

00:10:49.600 --> 00:10:51.580
automatisch steuern kann. Das ist natürlich ganz spannend,

00:10:51.740 --> 00:10:53.680
weil man hat halt irgendwie ganz viel

00:10:53.680 --> 00:10:55.380
kleines Zubehör, das irgendwie, wenn ich das richtig mal verstehe,

00:10:55.440 --> 00:10:57.180
meistens so in C am besten programmiert ist.

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

00:10:59.580 --> 00:11:01.560
oder sowas, die man da drauf schmeißt und kann dann einfach in Python

00:11:01.560 --> 00:11:02.700
auch die ganzen Module nehmen.

00:11:03.980 --> 00:11:05.280
Ja, also die ganzen

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

00:11:07.420 --> 00:11:09.040
das ist ja die Frage. Also man kann das, wenn das so

00:11:09.040 --> 00:11:11.200
Arduino-mäßig ist, ist das auf C, was man

00:11:11.200 --> 00:11:12.200
normalerweise schreibt, aber

00:11:12.200 --> 00:11:15.240
es gibt halt auch mittlerweile Chips, auf denen

00:11:15.240 --> 00:11:17.220
man Mikro-Python

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

00:11:19.000 --> 00:11:21.100
Die haben halt WLAN und ansonsten hast du

00:11:21.100 --> 00:11:23.120
ein Problem, wie kommunizierst du eigentlich mit Sensoren

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

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

00:11:27.280 --> 00:11:29.280
irgendwie das über Funk, DVB-T oder so

00:11:29.280 --> 00:11:30.660
machen, also ein bisschen ätzend.

00:11:31.160 --> 00:11:33.180
Und WLAN ist natürlich schon nicht so schlecht und das geht eigentlich

00:11:33.180 --> 00:11:35.180
mit alles mittlerweile. Aber halt eben, ich glaube,

00:11:35.220 --> 00:11:36.920
der größte Punkt ist, dass Home Assistant

00:11:36.920 --> 00:11:39.180
ist halt in Falken geschrieben und das ist halt das Ding,

00:11:39.300 --> 00:11:40.980
was zum Verwalten von diesem ganzen Kram halt

00:11:40.980 --> 00:11:43.160
üblicherweise so verwendet wird, wenn man

00:11:43.160 --> 00:11:45.160
jetzt nicht irgendeine fertige Lösung

00:11:45.160 --> 00:11:47.240
wie jetzt, na, wie heißt

00:11:47.240 --> 00:11:49.140
das denn, von Apple

00:11:49.140 --> 00:11:55.060
oder Google oder

00:11:55.060 --> 00:11:57.240
Amazon oder so, die haben natürlich ihre

00:11:57.240 --> 00:11:57.840
eigenen Geschichten.

00:11:59.640 --> 00:12:01.280
Und was ich da interessant, ich habe da letztens noch mal

00:12:01.280 --> 00:12:03.260
genau in dem Zusammenhang mir dieses State of the

00:12:03.260 --> 00:12:04.620
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.720
klar, dass die mittlerweile unter den

00:12:12.720 --> 00:12:14.220
Top Ten der

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

00:12:16.380 --> 00:12:18.440
Contributions kriegen. Okay, cool.

00:12:18.900 --> 00:12:20.420
Ja, weil die Leute am meisten gerne daran basteln, ne?

00:12:20.420 --> 00:12:22.380
Ja, ich war

00:12:22.380 --> 00:12:24.080
überrascht, wie viel das ist, weil

00:12:24.080 --> 00:12:26.540
das ist ja jetzt eben noch nicht so prominent

00:12:26.540 --> 00:12:28.640
als, ich glaube, es waren sowieso sehr wenig

00:12:28.640 --> 00:12:30.180
Open-Source-Projekte in den ersten 10.

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

00:12:32.740 --> 00:12:34.740
auch so ein bisschen erschreckend. Wir haben doch keine

00:12:34.740 --> 00:12:36.780
Zeit. Aber sowas wie

00:12:36.780 --> 00:12:37.960
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 10, TensorFlow und so.

00:12:42.500 --> 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.280 --> 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.700
ansonsten, ja, alles was irgendwie

00:12:52.700 --> 00:12:53.400
noch so an

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

00:12:58.320 --> 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:02.740
vertreten. Das heißt, Web, hat man doch so ganz kurz gesagt,

00:13:02.820 --> 00:13:04.280
ich glaube, ist gar nicht so klein, oder?

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

00:13:06.400 --> 00:13:08.220
Also Django und Flask sind ungefähr

00:13:08.220 --> 00:13:09.980
beide gleich groß, mehr oder weniger.

00:13:11.540 --> 00:13:12.660
Und es sind beides

00:13:12.660 --> 00:13:15.020
große Bereiche,

00:13:15.140 --> 00:13:15.600
in denen es passiert.

00:13:16.200 --> 00:13:18.000
Viele der Top-Seiten sind irgendwie

00:13:18.000 --> 00:13:19.040
eins von beiden.

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

00:13:22.480 --> 00:13:24.680
Ziemliche Allround-Sprache eigentlich, kann man sagen.

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

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

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

00:13:30.500 --> 00:13:58.900
Hm, das, äh, hm, ich weiß nicht, also ich glaube, da kann man, das ist immer ein bisschen schwer, ne, wenn man das dann sagt, was Leute da machen sollen, und dann sagt irgendwie die Library oder das, das ist besonders interessant zur Zeit, dann braucht man irgendwie eine gewisse Zeit, um das zu lernen, wobei die meiste Zeit, die man braucht, um das zu lernen, wahrscheinlich dabei drauf geht, programmieren zu lernen, das dauert halt einfach lange, und dann ist es halt in dem Moment, wo man es kann, wieder veraltet.

00:13:58.900 --> 00:14:15.040
Also insofern, das hilft alles nicht, aber ich würde sagen, tatsächlich die Geschichte, die am meisten bringt und von der aus man dann alle anderen Sachen, die man vielleicht lernen kann, ist halt tatsächlich einfach richtig programmieren können. Das ist schon so die Fähigkeit, die man haben sollte.

00:14:15.040 --> 00:14:18.480
oder es ist halt auch etwas, was nicht so, es ist ja, ja.

00:14:19.020 --> 00:14:20.800
Richtig programmieren können, das hört sich jetzt total einfach an.

00:14:20.800 --> 00:14:23.800
Das hört sich total einfach an, aber das ist tatsächlich nicht so verbreitet,

00:14:23.940 --> 00:14:26.480
wie man sich das wünschen würde.

00:14:26.740 --> 00:14:30.080
Also das kann man immer, man denkt immer so, ja, das macht man halt irgendwie,

00:14:30.160 --> 00:14:32.660
dann machen Leute irgendwie einen Kurs oder kaufen sich irgendwie,

00:14:32.720 --> 00:14:35.200
ich weiß nicht, ob es sowas überhaupt gibt, Python in 21 Tagen oder Java.

00:14:36.600 --> 00:14:39.280
Das geht nicht in 21 Tagen, das geht auch nicht in einem halben Jahr,

00:14:39.480 --> 00:14:40.660
das dauert alles ein bisschen länger.

00:14:40.940 --> 00:14:43.720
Ja, manche Leute denken ja, dass wenn sie die Syntax mal gesehen haben.

00:14:43.720 --> 00:14:45.580
Genau, dass das das Gleiche wäre,

00:14:45.660 --> 00:14:46.420
aber das stimmt halt nicht.

00:14:47.840 --> 00:14:49.660
Die Syntax ist ja auch bei Programmiersprachen

00:14:49.660 --> 00:14:51.720
eigentlich gar nicht so...

00:14:51.720 --> 00:14:53.340
Also für Anfänger schon, die verstehen

00:14:53.340 --> 00:14:55.580
erst mal überhaupt nicht, was da steht. Das ist der erste Schritt

00:14:55.580 --> 00:14:57.320
zum Verstehen, 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.500
es gibt halt viel weniger Worte. Es gibt halt ein paar

00:15:01.500 --> 00:15:02.700
ja,

00:15:03.660 --> 00:15:05.200
es gibt ein paar

00:15:05.200 --> 00:15:06.580
Verben sozusagen für Worte.

00:15:06.680 --> 00:15:08.540
Hast du aber die ganze Standard-Library mit bedacht?

00:15:09.160 --> 00:15:11.200
Klar, also die Libraries sind dann nochmal ein anderes Thema,

00:15:11.200 --> 00:15:13.300
aber das muss man ja auch alles gar nicht so unbedingt

00:15:13.300 --> 00:15:13.680
können.

00:15:15.440 --> 00:15:17.600
Wenn man die Syntax und halt die paar

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

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

00:15:22.600 --> 00:15:22.960
Ja, also

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

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

00:15:27.680 --> 00:15:29.140
können oder halt auch

00:15:29.140 --> 00:15:31.240
Fremdsprache lernen oder so und das ist halt eine Geschichte,

00:15:31.360 --> 00:15:33.360
die dauert einfach. Da gibt es

00:15:33.360 --> 00:15:35.160
dann halt auch Sachen, wie man das schneller hinkriegt und

00:15:35.160 --> 00:15:36.780
wie man das effektiver üben kann und so.

00:15:38.680 --> 00:15:39.040
Aber

00:15:39.040 --> 00:15:41.200
wenn man das dann kann,

00:15:41.200 --> 00:15:43.620
dann 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:48.480 --> 00:15:49.600
Und das ist halt

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

00:15:51.220 --> 00:15:53.540
Geschichte, die man

00:15:53.540 --> 00:15:54.140
können sollte.

00:15:55.080 --> 00:15:56.380
Sich in Themen schnell einarbeiten.

00:15:56.980 --> 00:15:59.520
Ja, beziehungsweise die Prinzipien des Programmierens.

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

00:16:01.360 --> 00:16:02.700
vorher erledigt haben, weil das

00:16:02.700 --> 00:16:05.780
wird einem niemand gerne bezahlen wollen,

00:16:05.780 --> 00:16:07.140
sondern das lernt man, das

00:16:07.140 --> 00:16:09.800
lange dauert. Aber ich würde auch sagen,

00:16:09.860 --> 00:16:11.080
da gibt es halt enormes Potenzial.

00:16:11.400 --> 00:16:12.740
Jetzt hört sich so ein bisschen an, das kann das ja jeder,

00:16:12.860 --> 00:16:13.820
aber das ist nicht so.

00:16:13.960 --> 00:16:17.520
Also die allermeisten haben damit Probleme und strugglen da.

00:16:17.760 --> 00:16:21.560
Und nicht die Mehrheit aller Programmierer

00:16:21.560 --> 00:16:23.160
kann ordentlich programmieren, würde ich jetzt mal so sagen.

00:16:23.860 --> 00:16:25.220
Ja, das musst du eigentlich noch definieren,

00:16:25.280 --> 00:16:25.860
was denn ordentlich programmiert ist.

00:16:25.860 --> 00:16:28.860
Und das ist vielleicht auch, das kann ich ehrlich gesagt

00:16:28.860 --> 00:16:29.420
gar nicht so genau.

00:16:29.680 --> 00:16:30.760
Und es ist auch die Frage,

00:16:30.880 --> 00:16:32.280
eigentlich ist es auch wieder so ein bisschen,

00:16:32.920 --> 00:16:35.100
ich will eigentlich niemanden ausschließen.

00:16:36.660 --> 00:16:38.400
Ich würde sagen, ja,

00:16:38.420 --> 00:16:40.400
selbst wenn man das nicht so total hundertprozentig kann.

00:16:40.880 --> 00:16:42.440
Wahrscheinlich haben die meisten von uns

00:16:42.440 --> 00:16:44.360
auch schon irgendwie Jobs gemacht, wo sie

00:16:44.360 --> 00:16:46.360
dachten, dass sie dafür eigentlich gar nicht geeignet

00:16:46.360 --> 00:16:48.040
wären oder so und das haben dann halt irgendwie gelernt.

00:16:48.960 --> 00:16:50.060
So ist das halt auch

00:16:50.060 --> 00:16:52.240
normal, das ist wahrscheinlich auch in anderen Bereichen

00:16:52.240 --> 00:16:54.380
so und vielleicht

00:16:54.380 --> 00:16:56.020
muss man sich einfach mal trauen, irgendwas zu machen

00:16:56.020 --> 00:16:58.240
oder zu sagen, dass man irgendwas kann, auch wenn man es halt vielleicht nur so

00:16:58.240 --> 00:16:59.800
ein bisschen kann und dann nicht so total perfekt.

00:17:02.060 --> 00:17:04.320
Ja, aber du musst ja trotzdem damit rausholen,

00:17:04.400 --> 00:17:06.180
was denn jetzt richtiges Programmieren dann überhaupt ist.

00:17:06.320 --> 00:17:08.220
Also das ist ja zwar eigentlich jetzt nicht auf meiner Liste, aber dann musst

00:17:08.220 --> 00:17:10.180
du jetzt in kleinen Kurvortrag teilen? Ich gebe dir sogar

00:17:10.180 --> 00:17:10.660
zwei Minuten.

00:17:12.280 --> 00:17:14.300
Naja, das wäre

00:17:14.300 --> 00:17:15.740
gar kein Problem, das sind zwei Minuten, ist ja klar.

00:17:16.840 --> 00:17:18.180
Also ich würde

00:17:18.180 --> 00:17:19.080
sagen, wenn man halt

00:17:19.080 --> 00:17:21.800
nichts total, also wenn man

00:17:21.800 --> 00:17:24.240
Dinge so macht, wie sie gemacht werden

00:17:24.240 --> 00:17:26.000
sollten, nicht so total schrecklich

00:17:26.000 --> 00:17:27.280
Dinge falsch macht, vielleicht.

00:17:28.060 --> 00:17:30.140
Weil tatsächlich ist es das, was man oft sieht, dass Sachen

00:17:30.140 --> 00:17:31.920
halt wirklich, also nicht

00:17:31.920 --> 00:17:34.140
nur so ein bisschen nicht ordentlich

00:17:34.140 --> 00:17:36.060
sind, sondern so Kleinigkeiten, sondern

00:17:36.060 --> 00:17:38.100
dass so Dinge so gar nicht richtig sind eigentlich.

00:17:38.220 --> 00:17:39.900
Was gehört denn dazu, also was würde denn da?

00:17:40.280 --> 00:17:41.880
Also ich würde sagen eben, dass

00:17:41.880 --> 00:17:43.340
der Umgang mit den

00:17:43.340 --> 00:17:45.560
ganz einfachen

00:17:45.560 --> 00:17:48.280
Datenstrukturen, ja, also

00:17:48.280 --> 00:17:49.400
irgendwie Listen,

00:17:50.240 --> 00:17:50.560
Dicks,

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

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

00:17:56.480 --> 00:17:57.120
hat man schon viel,

00:17:58.080 --> 00:18:00.280
weil das schon viele Leute nicht so richtig hinkriegen

00:18:00.280 --> 00:18:02.220
und ja,

00:18:02.420 --> 00:18:03.080
dann halt,

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

00:18:06.060 --> 00:18:07.900
Sachen halt ordentlich in Funktionen packt,

00:18:07.940 --> 00:18:09.780
nicht irgendwie Spaghetti-Gut schreibt, dass das halt alles so

00:18:09.780 --> 00:18:11.740
halbwegs, sondern sich nicht

00:18:11.740 --> 00:18:13.920
dauernd wiederholt. Dry, don't

00:18:13.920 --> 00:18:14.440
repeat yourself.

00:18:15.740 --> 00:18:17.840
Ja, aber da

00:18:17.840 --> 00:18:19.760
gehen wir fast schon in diese Detailgeschichten,

00:18:19.880 --> 00:18:21.860
oder dass man halt Tests schreibt und diese ganzen

00:18:21.860 --> 00:18:23.740
Best Practices verwendet

00:18:23.740 --> 00:18:25.440
und Versionskontrolle verwendet und so.

00:18:25.660 --> 00:18:27.740
Mit den Daten schon, das musst du später nochmal sagen, da habe ich noch ein paar

00:18:27.740 --> 00:18:29.800
Fragen, da müssen wir nochmal ein bisschen drauf eingehen, was denn

00:18:29.800 --> 00:18:31.360
überhaupt jetzt im Skalar-Daten schon

00:18:31.360 --> 00:18:32.760
was alles ist, ja.

00:18:33.640 --> 00:18:35.820
Okay, also du sagst halt einfach, okay, man muss halt die Prinzipien

00:18:35.820 --> 00:18:37.480
Best Practices irgendwie kennen und anwenden

00:18:37.480 --> 00:18:39.420
und sich daran so ein bisschen hochhangeln und

00:18:39.420 --> 00:18:40.980
irgendwie sich was besorgen, was man da...

00:18:40.980 --> 00:18:42.880
Ja, und viel Code lesen, halt viel

00:18:42.880 --> 00:18:45.360
sich mal angucken. Das Problem ist natürlich, wenn man

00:18:45.360 --> 00:18:47.320
jetzt jemanden liest, wo du sagst, die Mehrheit der Programmierer

00:18:47.320 --> 00:18:49.580
ist gar nicht so hervorragend

00:18:49.580 --> 00:18:50.900
und dann lese ich jetzt von...

00:18:50.900 --> 00:18:53.240
Ich würde es vielleicht anders sagen,

00:18:53.480 --> 00:18:55.300
da ist viel Verbesserungspotenzial. Also wenn man sich anguckt,

00:18:55.480 --> 00:18:57.440
was, wenn der Code, der geschrieben

00:18:57.440 --> 00:18:59.160
wird von Leuten oder der so in Firmen

00:18:59.160 --> 00:19:01.320
läuft oder so, ist das dann so, wie es

00:19:01.320 --> 00:19:03.360
sein könnte oder kann da noch, geht da noch mehr?

00:19:03.820 --> 00:19:05.400
Und da muss man sagen, da geht eigentlich

00:19:05.400 --> 00:19:07.040
fast immer noch deutlich mehr.

00:19:07.400 --> 00:19:09.000
Ja gut, aber wenn man sich jetzt seinen eigenen Code anguckt,

00:19:09.160 --> 00:19:11.180
dann ein halbes Jahr später, dann denkt man natürlich schon so,

00:19:11.180 --> 00:19:12.080
oh, was willst du sagen.

00:19:12.500 --> 00:19:13.160
Ist das auch so, ja.

00:19:14.240 --> 00:19:15.820
Genau, aber ja.

00:19:17.340 --> 00:19:20.260
Ja, was, erstmal, also ich habe noch eine Basisfrage bekommen

00:19:20.260 --> 00:19:21.420
vom Olli, der hat ja noch geschrieben,

00:19:21.520 --> 00:19:24.680
Tipps für eine gute Syntax, dein Top 5 oder so.

00:19:26.560 --> 00:19:28.340
Heute, heutzutage würde ich sagen, Black verwenden

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

00:19:30.820 --> 00:19:31.900
Also einfach Black, bumm.

00:19:31.940 --> 00:19:32.080
Ja.

00:19:32.920 --> 00:19:34.140
Vielleicht, also Namen vielleicht auch.

00:19:35.540 --> 00:20:05.520
Namen sind natürlich, das ist eine ganz schwierige Sache, also wie kommt man da auf gute Namen, da muss man auch lange drüber nachdenken oft, also ja, da gibt es ja auch immer den bekannten Witz, was sind die zwei schwierigen Sachen, ja, in der Informatik irgendwie Dinge benennen, Caching und oft bei One-Error-Errors, ja, aber genau, also Dinge benennen ist schwierig, ist eine Kunst und ja, wo man sich da auch dran orientieren kann,

00:20:05.540 --> 00:20:07.620
Ist so ein bisschen wie bei gutem Kommentaren.

00:20:08.060 --> 00:20:09.340
Man sollte eher darauf achten,

00:20:09.920 --> 00:20:11.600
hinzuschreiben, warum man das

00:20:11.600 --> 00:20:13.480
macht oder was das macht. Nicht so

00:20:13.480 --> 00:20:15.660
sehr, wie da irgendwas passiert oder so.

00:20:18.000 --> 00:20:19.540
Ja, und halt dabei,

00:20:19.900 --> 00:20:20.600
wenn man was schreibt,

00:20:20.860 --> 00:20:22.940
dran denken, dass das,

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

00:20:25.720 --> 00:20:27.320
dann halt verständlich sein sollte, weil

00:20:27.320 --> 00:20:28.840
Code viel öfter gelesen wird als geschrieben.

00:20:30.120 --> 00:20:30.240
Ja.

00:20:32.380 --> 00:20:33.360
Was ist mit sowas wie

00:20:33.360 --> 00:20:35.440
List Comprehensions? Würdest du das bevorzugen,

00:20:35.540 --> 00:20:36.720
gegenüber klassischen Loops.

00:20:36.720 --> 00:20:39.500
Kommt drauf an. Also ich würde sogar

00:20:39.500 --> 00:20:41.560
eher ein bisschen, die andere,

00:20:41.660 --> 00:20:43.180
ich würde sagen, lieber eine

00:20:43.180 --> 00:20:45.160
Vorschleife verwenden und

00:20:45.160 --> 00:20:47.320
List Comprehension halt eher dann, wenn es halt

00:20:47.320 --> 00:20:49.180
irgendwas einfacher ist, wo

00:20:49.180 --> 00:20:51.480
ja, wenn es halt offensichtlich und einfach

00:20:51.480 --> 00:20:52.840
ist, dann kann man auch gerne

00:20:52.840 --> 00:20:55.480
List Comprehension verwenden. Aber wenn man

00:20:55.480 --> 00:20:56.580
also, ich meine,

00:20:58.600 --> 00:20:59.340
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 ich habe dann auch schon

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

00:21:07.100 --> 00:21:08.340
wo ich dann halt

00:21:08.340 --> 00:21:11.180
mehrfach verschachtelt irgendwie

00:21:11.180 --> 00:21:13.220
über Dinge iteriert habe. Und das wird bei

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

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

00:21:16.900 --> 00:21:19.040
stolz darauf war, so ein Statement hingekriegt zu haben.

00:21:19.600 --> 00:21:20.560
Einer Zeile, Goldgolf.

00:21:20.620 --> 00:21:23.200
Nicht in einer Zeile, das geht dann halt nicht mehr in einer Zeile, aber

00:21:23.200 --> 00:21:25.120
dann so drei Zeilen List Comprehension

00:21:25.120 --> 00:21:27.180
irgendwie mit Bedingungen drin

00:21:27.180 --> 00:21:29.260
und verschachtelt und so lange

00:21:29.260 --> 00:21:31.100
getüftelt, bis es irgendwie ordentlich funktioniert hat.

00:21:31.440 --> 00:21:33.260
Das macht ja dann auch irgendwie Spaß. Das ist halt so ein bisschen

00:21:33.260 --> 00:21:34.880
wie puzzeln, aber

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

00:21:37.340 --> 00:21:37.580
der das

00:21:37.580 --> 00:21:41.100
verstehen muss und das unter einem gewissen

00:21:41.100 --> 00:21:42.080
Zeitdruck tut, dann

00:21:42.080 --> 00:21:44.900
würde der sich wahrscheinlich irgendwie

00:21:44.900 --> 00:21:46.100
Rot vor Rot.

00:21:46.860 --> 00:21:47.900
Spaß zur Ärger.

00:21:48.420 --> 00:21:50.060
Da gibt es

00:21:50.060 --> 00:21:52.400
das Remote Strangulation Protocol,

00:21:52.720 --> 00:21:54.020
wie zu Hilfe wünschen.

00:21:54.580 --> 00:21:55.480
Das Remote Strangulation Protocol?

00:21:55.480 --> 00:21:55.760
Ja.

00:21:58.240 --> 00:21:59.100
Ich weiß nicht.

00:22:01.300 --> 00:22:02.580
Das kennt wahrscheinlich auch keiner.

00:22:03.000 --> 00:22:04.180
Damals gab es so einen Text

00:22:04.180 --> 00:22:05.620
auch schon lange her,

00:22:06.440 --> 00:22:07.440
Bastard Operator from Hell

00:22:07.440 --> 00:22:09.860
und da gibt es die

00:22:09.860 --> 00:22:11.900
sysadmin, also es gibt die

00:22:11.900 --> 00:22:13.180
sysadmin-man-pages oder die

00:22:13.180 --> 00:22:16.280
sysadmin-recovery

00:22:16.280 --> 00:22:17.220
gab es in Newsgroup

00:22:17.220 --> 00:22:19.340
und dann

00:22:19.340 --> 00:22:22.180
ASR, alt sysadmin-recovery

00:22:22.180 --> 00:22:24.020
das war die Newsgroup und dann gab es die

00:22:24.020 --> 00:22:25.620
ASR-man-pages und Tools

00:22:25.620 --> 00:22:26.860
ich glaube, wenn man

00:22:26.860 --> 00:22:29.880
man-asr sagt oder man-knife

00:22:29.880 --> 00:22:31.760
oder man-snip oder so,

00:22:31.940 --> 00:22:33.760
dann kriegt man das auch noch irgendwie

00:22:33.760 --> 00:22:35.780
auf dem Linux zu sehen.

00:22:35.920 --> 00:22:37.200
Da gibt es dann Tools, mit denen man

00:22:37.200 --> 00:22:38.240
irgendwie Usern

00:22:38.240 --> 00:22:41.360
die Attitüde

00:22:41.360 --> 00:22:42.740
von Usern wieder

00:22:42.740 --> 00:22:45.660
rejustieren kann. Und diese Tools sind halt

00:22:45.660 --> 00:22:47.400
sowas wie Snip

00:22:47.400 --> 00:22:49.960
oder Knife

00:22:49.960 --> 00:22:50.700
ist da X.

00:22:51.920 --> 00:22:53.720
Mit der Axt irgendwie mal dazwischen geht

00:22:53.720 --> 00:22:55.360
und Dinge gerade richtet.

00:22:55.500 --> 00:22:57.760
Die Attitüde von Usern regulieren, das hört sich

00:22:57.760 --> 00:22:59.520
toll an. Ja, das klingt

00:22:59.520 --> 00:23:01.580
nach Spaß an,

00:23:01.580 --> 00:23:03.060
wenn man auf der richtigen Seite steht.

00:23:03.760 --> 00:23:24.740
Ja, ist natürlich so ein bisschen, ich meine, das Mindset dahinter ist auch etwas fragwürdig, aber es ist damals irgendwie lustig. Und da gab es auch Protokolle und eines der Protokolle in dem Zusammenhang ist halt das RSTP, Remote Strangulation Protokoll über Fernverbindungen.

00:23:25.180 --> 00:23:34.240
Sehr gut, das ist das, was man in Startorganisationen gerne hätte oder wo man dran arbeitet, das automatisch zu bekommen. Also ihr braucht gute Admins für den Start, damit das funktioniert.

00:23:35.960 --> 00:23:45.400
Ja, also ein bisschen Syntax haben wir gemacht. Also die Frage wäre jetzt noch, was gehört als zu Python Fullstack dann? Also wenn man jetzt schon ganz viel kann und so, was würdest du sagen, wenn man richtig Fullstack entwickelt?

00:23:45.400 --> 00:23:47.600
Ja, Fullstack, das ist so ein Ding, was heutzutage

00:23:47.600 --> 00:23:49.520
auch wieder in aller Munde ist, wobei das

00:23:49.520 --> 00:23:51.620
auch selten tatsächlich so ist.

00:23:52.700 --> 00:23:53.380
Würde ich sogar sagen,

00:23:53.520 --> 00:23:55.240
auch das, ich mach das nicht eigentlich.

00:23:55.520 --> 00:23:57.900
Ich bin deutlich eher auf der Backend-Seite als auf der

00:23:57.900 --> 00:23:59.500
Frontend-Seite, aber Fullstack hieße ja,

00:23:59.580 --> 00:24:01.380
dass du quasi alles machen kannst, von

00:24:01.380 --> 00:24:03.580
unten bis Frontend. Also Fullstack in Python

00:24:03.580 --> 00:24:05.300
geht gar nicht, weil man kein Frontend kann. Das geht nicht richtig, genau,

00:24:05.440 --> 00:24:07.180
weil du mit Frontend bist du halt nicht,

00:24:08.160 --> 00:24:09.480
da brauchst du halt dann schon JavaScript

00:24:09.480 --> 00:24:11.040
für und

00:24:11.040 --> 00:24:13.600
ja, oder es ginge theoretisch

00:24:13.600 --> 00:24:15.620
auch. Aber das ist halt ein Bereich, der schön wäre,

00:24:15.700 --> 00:24:17.660
wenn das mit Python funktionieren würde. Aber momentan

00:24:17.660 --> 00:24:19.580
geht das nicht richtig. Also man könnte natürlich Python

00:24:19.580 --> 00:24:21.740
auch irgendwie Richtung WebAssembly

00:24:21.740 --> 00:24:23.500
kompilieren und dann halt im Frontend verwenden.

00:24:23.720 --> 00:24:25.760
Aber es gibt keine, es gibt

00:24:25.760 --> 00:24:27.600
eben nicht so viel wie für JavaScript

00:24:27.600 --> 00:24:29.660
die ganzen UI-Bibliotheken, die man

00:24:29.660 --> 00:24:31.420
da so braucht, um halt Dinge irgendwie

00:24:31.420 --> 00:24:32.660
auszumachen. Also

00:24:32.660 --> 00:24:34.020
schwierig.

00:24:35.920 --> 00:24:37.700
Ja, das heißt, JavaScript braucht ihr, wenn ihr Full-Tag

00:24:37.700 --> 00:24:39.680
machen wollt. Und mit Python kriegt ihr das gar nicht so hin.

00:24:40.140 --> 00:24:41.700
Aber vielleicht wollt ihr das ja auch gar nicht so machen,

00:24:41.700 --> 00:24:43.380
weil warum sollte man Full-Tag machen, wenn man

00:24:43.380 --> 00:24:45.500
die anderen Sachen wie Data und Backend so gut kann.

00:24:45.520 --> 00:24:47.040
Naja, also wenn du eine Webseite machst, hast du

00:24:47.040 --> 00:24:49.340
sofort diesen ganzen Kram, wobei du da

00:24:49.340 --> 00:24:51.200
möglicherweise eben auch ohne JavaScript oder

00:24:51.200 --> 00:24:53.320
ohne viel JavaScript auskommen kannst.

00:24:54.160 --> 00:24:55.560
So eine ganz stinknormale

00:24:55.560 --> 00:24:57.340
Webseite, so.

00:24:57.660 --> 00:24:59.600
Ein bisschen CSS-Version machen

00:24:59.600 --> 00:25:01.260
oder sowas, ja. Auch kein Python.

00:25:01.780 --> 00:25:02.960
Auch wieder kein Python, genau.

00:25:03.560 --> 00:25:05.320
Aber das geht natürlich auch immer noch und

00:25:05.320 --> 00:25:06.820
ist eigentlich auch für viele Anwendungen

00:25:06.820 --> 00:25:08.680
irgendwie gar nicht so schlecht.

00:25:09.520 --> 00:25:11.220
Aber, ja. Ja, gibt ja so ein paar

00:25:11.220 --> 00:25:13.280
Framework, ne? Grid, Materialize,

00:25:13.380 --> 00:25:15.280
so. Naja, also ohne

00:25:15.280 --> 00:25:17.220
JavaScript. Aber das ist ja was anderes. Ja, also Fullstack geht

00:25:17.220 --> 00:25:18.300
gar nicht nur mit Python.

00:25:18.740 --> 00:25:21.640
Und das ist tatsächlich auch einer der großen

00:25:21.640 --> 00:25:23.460
Risiken

00:25:23.460 --> 00:25:25.080
irgendwie für die Zukunft von Python, wenn das

00:25:25.080 --> 00:25:26.960
halt, wenn das quasi so aus dem

00:25:26.960 --> 00:25:28.740
Wettding, weil die Frage ist jetzt,

00:25:28.900 --> 00:25:30.820
kommt Python nochmal ins Frontend oder

00:25:30.820 --> 00:25:33.140
geht JavaScript ins Backend?

00:25:33.520 --> 00:25:35.220
Und wenn der Weg in die Zukunft

00:25:35.220 --> 00:25:37.180
so aussieht, das wird dann JavaScript, weil das natürlich auch

00:25:37.180 --> 00:25:38.240
gewisse Vorteile bringt. Du kannst

00:25:38.240 --> 00:25:40.920
einmal den Code, kannst ihn im Backend und

00:25:40.920 --> 00:25:42.520
im Frontend verwenden.

00:25:43.380 --> 00:25:45.500
wenn wir jetzt auch im Backend zunehmend

00:25:45.500 --> 00:25:47.160
JavaScript kriegen, dann brauchst du halt

00:25:47.160 --> 00:25:49.480
eigentlich Python in der Webentwicklung gar nicht mehr.

00:25:49.760 --> 00:25:51.360
Oder es läuft umgekehrt

00:25:51.360 --> 00:25:53.360
und wir kriegen auch irgendwann

00:25:53.360 --> 00:25:55.540
Python im Frontend, das wäre natürlich eigentlich die schönere Variante.

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

00:25:57.320 --> 00:25:58.640
passiert, das ist natürlich eine gute Sache.

00:26:00.140 --> 00:26:01.460
Ich glaube, also die Chance ist gar nicht so schlecht,

00:26:01.600 --> 00:26:03.000
also ich glaube, Python ist noch

00:26:03.000 --> 00:26:05.300
bei Anfängern gerade ein bisschen beliebter, vielleicht bedeutet

00:26:05.300 --> 00:26:07.420
das, dass das irgendwann dann auch in diese Richtung

00:26:07.420 --> 00:26:09.020
driftet. Ja,

00:26:09.240 --> 00:26:10.620
mal schauen, wer weiß.

00:26:11.360 --> 00:26:13.000
Ja, noch ein Import-Sys.

00:26:13.380 --> 00:26:16.500
Ja, ich glaube, das hatten wir letztes Jahr auch schon mal.

00:26:16.920 --> 00:26:20.240
Ziemlich genau um diese Zeit hatten wir das nicht in der ersten Folge schon mal.

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

00:26:22.920 --> 00:26:24.980
Aber kann man sich auf jeden Fall immer mal wieder angucken.

00:26:25.220 --> 00:26:28.920
Ja, also den Interpreter öffnen, einfach Import-Sys eingeben und abschicken.

00:26:29.100 --> 00:26:29.580
Und dann seht ihr das.

00:26:29.700 --> 00:26:33.480
Also die Prinzipien, die man sich darauf geeinigt hat,

00:26:33.520 --> 00:26:35.640
die in Python gelten, sollen auch sein.

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

00:26:39.360 --> 00:26:40.760
Aber ja, ist auch was dran.

00:26:41.120 --> 00:26:43.100
Ja, das ist direkt verknüpft zu PEP 8.

00:26:43.220 --> 00:26:44.660
Ich glaube, das hatten wir dann auch schon mal kurz erwähnt, aber

00:26:44.660 --> 00:26:46.820
an der Stelle vielleicht nochmal. Ja, das ist sozusagen einfach nur die

00:26:46.820 --> 00:26:48.000
Art, wie man

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

00:26:50.320 --> 00:26:53.120
Konsens darüber,

00:26:53.240 --> 00:26:55.000
wie man Python-Code formatieren sollte

00:26:55.000 --> 00:26:55.940
vielleicht.

00:26:57.440 --> 00:26:58.860
Nee, wer macht das nicht, dann kommt hier in die

00:26:58.860 --> 00:27:01.020
Python-Hölle. Ja, aber auch innerhalb

00:27:01.020 --> 00:27:02.880
von Tab 8 gibt es ja so Dinge, die dann

00:27:02.880 --> 00:27:05.000
nicht geklärt sind dadurch und

00:27:05.000 --> 00:27:06.940
Black

00:27:06.940 --> 00:27:08.940
hat halt zum Beispiel eben eine Meinung dazu, wie das

00:27:08.940 --> 00:27:10.560
sein soll. Du kannst ja Dinge machen, die...

00:27:10.560 --> 00:27:12.980
Ich finde bei einigen Sachen total furchtbar, das sieht scheußlich aus.

00:27:13.220 --> 00:27:14.140
Okay, was denn?

00:27:14.720 --> 00:27:17.780
Ja, wenn ich zum Beispiel Argumente in Funktionen packe

00:27:17.780 --> 00:27:20.480
oder längere Print Statements schreibe,

00:27:21.240 --> 00:27:22.240
wie er die dann umbricht,

00:27:22.460 --> 00:27:25.100
dann macht er die Klammer auf in eine Zeile,

00:27:25.220 --> 00:27:27.660
dann nächste Zeile den String aus dem Print Statement

00:27:27.660 --> 00:27:29.760
und dann darunter die Klammer wieder zu,

00:27:30.220 --> 00:27:30.760
wo ich dann sagen würde,

00:27:30.840 --> 00:27:31.800
hey, für die fünf Zeilen,

00:27:31.920 --> 00:27:34.460
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 Einzel schreiben können.

00:27:36.520 --> 00:27:38.800
Oder halt, wenn Kommentare am Ende der Zeile sind,

00:27:38.960 --> 00:27:41.180
dann bricht er dann trotzdem die ganze Funktion auseinander,

00:27:41.300 --> 00:27:42.360
obwohl sie noch reinpassen würde.

00:27:43.020 --> 00:27:47.800
Oder wenn Black sagt, 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.700 --> 00:27:54.300
Das sieht auch ganz furchtbar aus.

00:27:54.460 --> 00:27:56.560
Und dann ist dann der, ich kann mal so mit dem Doppelpunkt,

00:27:56.840 --> 00:28:00.840
dann am Anfang von einer Zeile irgendwie drei Zeilen Funktionsdefinition.

00:28:01.220 --> 00:28:02.560
Das finde ich total furchtbar.

00:28:03.260 --> 00:28:07.220
Ich bin eh nicht so ein Freund von diesem 89 Zeichen Editor-Quatsch,

00:28:07.300 --> 00:28:09.180
weil ganz ehrlich, so entziehend,

00:28:09.880 --> 00:28:11.400
dass wir nur 89 Zeichen auf dem Bildschirm haben.

00:28:11.620 --> 00:28:11.880
79.

00:28:12.240 --> 00:28:15.080
Entschuldigung, ich entwickle nicht die ganze Zeit

00:28:15.080 --> 00:28:15.680
mit meinem Telefon.

00:28:16.460 --> 00:28:17.920
Nee, das ist für Konsolen eigentlich.

00:28:19.240 --> 00:28:20.660
Die haben halt bloß 80 Zeilen,

00:28:20.860 --> 00:28:22.460
also 24 Zeilen,

00:28:22.600 --> 00:28:25.080
80 Spalten.

00:28:26.440 --> 00:28:29.200
es gibt natürlich, oder ich weiß nicht...

00:28:29.200 --> 00:28:30.460
Ja, die alten, aber nur die neuen.

00:28:31.900 --> 00:28:32.880
Weiß ich nicht, ob es dann...

00:28:32.880 --> 00:28:33.860
Nee, der Standard ist immer noch so.

00:28:34.520 --> 00:28:36.800
Es ist auch so, wenn du jetzt auf dem Linux oder so bist,

00:28:36.800 --> 00:28:38.740
dann hast du ja nicht unbedingt immer ein grafisches System

00:28:38.740 --> 00:28:40.220
und deine Konsole sieht halt so aus.

00:28:40.400 --> 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:44.820 --> 00:28:45.600
Auf einer Konsole?

00:28:48.400 --> 00:28:52.880
Ja, also ohne grafische 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.840
dass jemand an einem Rechner ohne grafische Benutzeroberfläche sitzt,

00:28:57.940 --> 00:28:58.660
praktisch gar nicht mehr so.

00:28:58.660 --> 00:28:59.960
Also, wenn ich mich auf meinen Server einlogge,

00:29:00.020 --> 00:29:01.700
habe ich da mehr als 80.

00:29:01.700 --> 00:29:02.960
Ja, natürlich, aber du hast...

00:29:02.960 --> 00:29:04.040
Über die Konsole, über meine Shell.

00:29:04.680 --> 00:29:05.800
Hast du dich mal an eine Konsole gestellt,

00:29:05.900 --> 00:29:07.660
an einem Rechenzentrum, an eine serielle Konsole?

00:29:08.700 --> 00:29:11.380
Ich glaube, da hast du genau die 80 Spalten

00:29:11.380 --> 00:29:13.640
und 24. Das ist ja uralt

00:29:13.640 --> 00:29:15.400
DOS. Ja, bei DOS

00:29:15.400 --> 00:29:16.140
war das auch so, genau.

00:29:17.700 --> 00:29:19.560
Ja, ich

00:29:19.560 --> 00:29:20.120
weiß auch nicht.

00:29:21.160 --> 00:29:23.440
Also ich glaube auch nicht, das ist eigentlich nicht mehr relevant, aber

00:29:23.440 --> 00:29:25.180
da kommt das halt her und

00:29:25.180 --> 00:29:27.500
wenn, dann sieht man da halt, muss man kurz drauf aufpassen,

00:29:27.600 --> 00:29:29.220
dass es dann umgebrochene Zeilen gibt,

00:29:29.660 --> 00:29:31.440
die automatisch vielleicht eingeguckt werden

00:29:31.440 --> 00:29:33.580
oder so. Ich weiß gar nicht, auf was ich es gestellt

00:29:33.580 --> 00:29:35.380
habe bei mir. Das ist ja auch ein Ding, das man

00:29:35.380 --> 00:29:37.060
bei Black tatsächlich einstellen kann. Also da

00:29:37.060 --> 00:29:39.420
das muss man nicht

00:29:39.420 --> 00:29:41.180
so auf 79 zeichnen lassen.

00:29:41.380 --> 00:29:42.940
Also 79 Zeichen deswegen, weil man halt noch

00:29:42.940 --> 00:29:44.260
eins braucht für einen Zeilenumbruch.

00:29:47.100 --> 00:29:47.340
Aber

00:29:47.340 --> 00:29:48.460
wenn,

00:29:49.340 --> 00:29:51.000
also ich glaube, ich habe es auch irgendwo auf einer 10

00:29:51.000 --> 00:29:52.020
stehen, aber ich weiß es nicht.

00:29:52.900 --> 00:29:55.060
Jedenfalls, das kann man ja konfigurieren und dann ist es nicht mehr so schlimm.

00:29:55.340 --> 00:29:56.960
Also ich finde auch ein bisschen mehr als 80 geht schon.

00:29:57.720 --> 00:29:58.980
Irgendwann ist es natürlich auch wieder doof, wenn das

00:29:58.980 --> 00:29:59.500
halt zu lang wird.

00:30:00.380 --> 00:30:03.060
Also so, dass man es halt vernünftig auf einem normalen Arbeitsrechner

00:30:03.060 --> 00:30:04.920
irgendwie vernünftig anlesen kann, dass es dann nicht immer halb so

00:30:04.920 --> 00:30:06.440
groß ist, dass man viel zu viel Platz braucht.

00:30:06.500 --> 00:30:08.240
Das wäre ja völlig unheimlich und hässlich, einige Sachen.

00:30:08.600 --> 00:30:10.400
Also ich finde, DEC ist dann so ein bisschen inkonsistent,

00:30:10.500 --> 00:30:11.180
wenn es halt dann,

00:30:12.320 --> 00:30:14.120
beispielsweise, du hast drei Debug-Statements hintereinander,

00:30:14.200 --> 00:30:15.940
das eine ist vier Zeichen zu lang, dann bricht

00:30:15.940 --> 00:30:18.040
das ganz komisch rum irgendwie und die

00:30:18.040 --> 00:30:19.940
anderen darunter sehen

00:30:19.940 --> 00:30:21.960
nicht so aus. Das ist irgendwie komisch.

00:30:22.280 --> 00:30:22.360
Naja.

00:30:23.640 --> 00:30:26.000
Also ich finde das, wo mein ästhetisches Empfinden

00:30:26.000 --> 00:30:27.660
wird, da immer so ein bisschen angehört. Naja, gut.

00:30:30.220 --> 00:30:31.880
Wann ist man Amnesie-Syndrom erkrankt?

00:30:32.740 --> 00:30:32.900
Ah.

00:30:33.820 --> 00:30:35.260
Not invented hier, ja.

00:30:36.240 --> 00:30:37.180
Das, äh,

00:30:37.260 --> 00:30:42.280
Wenn man alles selber macht.

00:30:42.280 --> 00:30:44.100
Sehr böse erwischt.

00:30:44.640 --> 00:30:46.340
Ja, das ist halt das Problem.

00:30:46.560 --> 00:30:47.580
Genau, das heißt einfach nur,

00:30:48.260 --> 00:30:49.880
dass man halt versucht, alles selber zu machen.

00:30:50.320 --> 00:30:51.760
Und wenn es halt nicht von hier kommt,

00:30:51.900 --> 00:30:54.120
viele Firmen haben das auch, die ja alles

00:30:54.120 --> 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 empfinden das Rad nochmal von vorn.

00:31:00.080 --> 00:31:02.180
Genau. Das ist halt immer nett, da kann man immer was mit lernen.

00:31:02.440 --> 00:31:04.300
Also die Grundlagen zu verstehen, ist gar nicht so schlicht.

00:31:04.440 --> 00:31:05.800
Und hat man irgendwann nicht

00:31:05.800 --> 00:31:07.740
kein mehr, der versteht, wie es irgendwann mal gebaut

00:31:07.740 --> 00:31:09.640
worden ist, sondern nur noch Leute, die dann irgendwie

00:31:09.640 --> 00:31:11.700
auf dem Sand und der Asche von alten

00:31:11.700 --> 00:31:13.640
versunkenen Städten versuchen, neue Gebäude zu errichten

00:31:13.640 --> 00:31:15.360
und dann immer so, oh, da war eine Grube.

00:31:16.760 --> 00:31:17.800
Und dann steht es ja Palast

00:31:17.800 --> 00:31:19.740
zusammen. Das ist natürlich dann das, was man vielleicht verhindern will

00:31:19.740 --> 00:31:21.780
und deswegen ist das vielleicht auch gar nicht immer so schlecht.

00:31:22.220 --> 00:31:23.620
Aber natürlich kann man ja viel Zeit damit

00:31:23.620 --> 00:31:25.620
verschwinden, 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.360
obwohl man eigentlich schon irgendwie fliegen könnte, dann

00:31:29.360 --> 00:31:31.440
naja. Ja, es ist

00:31:31.440 --> 00:31:33.440
immer schwierig. Man muss da halt eine richtige

00:31:33.440 --> 00:31:35.080
Balance finden. Es ist manchmal gut,

00:31:35.800 --> 00:31:38.020
Dinge, also ein Beispiel dafür wäre auch

00:31:38.020 --> 00:31:40.000
dieses Timestamp-Modell aus den

00:31:40.000 --> 00:31:42.140
Model-Utils, ja, deswegen haben alle als Abhängigkeit

00:31:42.140 --> 00:31:43.420
Model-Utils drin,

00:31:44.320 --> 00:31:45.380
dabei, ja,

00:31:46.220 --> 00:31:47.260
man ist dann auch so,

00:31:47.920 --> 00:31:49.300
wie meinte ich, über Django 3 kurz

00:31:49.300 --> 00:31:51.980
auch gesprochen

00:31:51.980 --> 00:31:54.020
und da hat er dann so, naja,

00:31:54.080 --> 00:31:55.340
das sind halt eigentlich zwei Zeilen,

00:31:55.420 --> 00:31:57.960
irgendwie in einem Modell, wenn man das selber

00:31:57.960 --> 00:31:58.960
macht, das ist,

00:31:59.800 --> 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:07.980
dass wenn man, das ist ja auch wieder

00:32:07.980 --> 00:32:09.080
blöd, wenn man nichts selber macht,

00:32:09.540 --> 00:32:12.240
ganz schlimmen NPM hat das ja auch so bei JavaScript-Geschichten,

00:32:12.940 --> 00:32:13.880
dann hast du halt,

00:32:14.960 --> 00:32:15.760
musst du dich halt

00:32:15.760 --> 00:32:18.000
viel mit dieser Maintenance von diesem Kram

00:32:18.000 --> 00:32:19.840
beschäftigen, was ja auch blöd ist.

00:32:20.040 --> 00:32:21.980
Ja, Parkway-Resonierung muss immer stimmen

00:32:21.980 --> 00:32:23.840
und genau in dem Zustand bleiben

00:32:23.840 --> 00:32:26.080
und wenn du irgendwelche Bugs hast, musst du dann irgendwas updaten,

00:32:26.120 --> 00:32:27.820
weil irgendwas kritisch war und das hat dann

00:32:27.820 --> 00:32:29.960
andere Abhängigkeiten und dann fliegt dir irgendwas auseinander,

00:32:30.060 --> 00:32:31.980
weil das inkompatibel ist mit irgendeiner neuen Implementierung

00:32:31.980 --> 00:32:33.080
von irgendeinem, ja.

00:32:33.500 --> 00:32:34.980
Also es ist halt auch, man kann nicht

00:32:34.980 --> 00:32:36.480
sagen, das eine ist super schlecht, das andere ist,

00:32:36.880 --> 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.340 --> 00:32:41.540
ja,

00:32:41.960 --> 00:32:44.440
irgendwie einen Weg finden, der

00:32:44.440 --> 00:32:46.720
für den Anwendungsfall, den man hat, den besten

00:32:46.720 --> 00:32:47.440
Trade-Off bietet.

00:32:49.020 --> 00:32:50.680
Aber tatsächlich ist es so, dass die

00:32:50.680 --> 00:32:52.540
meisten Leute eher zu viel Richtung

00:32:52.540 --> 00:32:54.220
Not-Invented hier gehen.

00:32:55.920 --> 00:32:56.780
Ja, manchmal

00:32:56.780 --> 00:32:58.780
ist das praktisch. Ich glaube, manchmal ist es auch gar nicht so

00:32:58.780 --> 00:33:00.780
schlecht, wenn man einfach coole Sachen, die cool funktionieren, einfach benutzen

00:33:00.780 --> 00:33:02.740
kann und die dann cool weiter funktionieren und

00:33:02.740 --> 00:33:04.780
dann auch einem schnell irgendwas

00:33:04.780 --> 00:33:06.820
ermöglichen zu entwickeln. Ich glaube, gerade für Anfänger ist das

00:33:06.820 --> 00:33:08.820
gar nicht schlecht, wenn man halt nicht von ganz immer

00:33:08.820 --> 00:33:10.720
anfängt, obwohl es natürlich auch nett ist, wenn man vielleicht

00:33:10.720 --> 00:33:12.600
erstmal Assembler lernt und dann C und dann

00:33:12.600 --> 00:33:14.780
guckt, wie es alles so funktioniert, aber es ist auch vielleicht ein bisschen

00:33:14.780 --> 00:33:16.700
aufwendig. Man kann vielleicht auch ab und zu

00:33:16.700 --> 00:33:18.440
mal eine High-Level-Bibliothek einfach benutzen,

00:33:18.860 --> 00:33:20.800
um zu gucken, wie man Dinge damit anstellt, ohne

00:33:20.800 --> 00:33:22.640
direkt alles zu verstehen oder selber zu

00:33:22.640 --> 00:33:23.560
implementieren. Ja,

00:33:24.560 --> 00:33:26.300
über die Zeit ist es natürlich so, dass auch

00:33:26.300 --> 00:33:28.580
der Level an Abstraktion, auf dem man

00:33:28.580 --> 00:33:30.440
arbeitet, wird halt immer höher eigentlich,

00:33:30.600 --> 00:33:32.540
weil halt immer mehr wird Commodity,

00:33:32.700 --> 00:33:33.920
also die Sachen, die früher

00:33:33.920 --> 00:33:36.660
der interessante

00:33:36.660 --> 00:33:38.620
Bereich war, in dem man irgendwas gemacht hat, die werden halt

00:33:38.620 --> 00:33:40.620
zunehmend Community und

00:33:40.620 --> 00:33:42.740
wandern halt sozusagen aus dem

00:33:42.740 --> 00:33:44.640
interessanten Feld raus und das,

00:33:44.920 --> 00:33:46.680
wo man die interessanten Sachen machen

00:33:46.680 --> 00:33:48.660
kann, das geht über die

00:33:48.660 --> 00:33:50.640
Zeit immer in abstrakter Geschichten. Das ist halt

00:33:50.640 --> 00:33:52.920
auch die Frage, inwiefern das nicht unter Umständen,

00:33:53.440 --> 00:33:54.740
also auf der einen

00:33:54.740 --> 00:33:56.040
Seite kann man sagen, man kann heute mit viel

00:33:56.040 --> 00:33:58.640
weniger Zeilencode irgendwie viel kompliziertere

00:33:58.640 --> 00:34:00.540
Dinge und tollere Sachen bauen, auf der

00:34:00.540 --> 00:34:02.500
anderen Seite ist es halt, wenn man sich das manchmal genauer anguckt,

00:34:02.700 --> 00:34:04.560
es ist halt ein, steht das

00:34:04.560 --> 00:34:06.300
alles so ein bisschen auf tönernen Füßen.

00:34:06.420 --> 00:34:08.580
Es ist halt so Kartenhaus über Kartenhaus geschichtet

00:34:08.580 --> 00:34:10.460
und irgendwie auf den unteren Ebenen

00:34:10.460 --> 00:34:12.500
stimmen schon viele Sachen nicht mehr so richtig, aber dann

00:34:12.500 --> 00:34:14.480
baut man halt so lange Abstraktionen drüber, bis es

00:34:14.480 --> 00:34:16.240
wieder, also ja,

00:34:16.420 --> 00:34:18.440
aber in Wirklichkeit hat man diese

00:34:18.440 --> 00:34:20.340
Probleme nicht wirklich gelöst. Ja, wenn man halt das Gebäude

00:34:20.340 --> 00:34:22.180
und den Palast aus der Samtgrube baut, man kann tatsächlich noch ein paar

00:34:22.180 --> 00:34:24.280
Stahlträger einziehen, das dann zu tun hat, könnte der Palast

00:34:24.280 --> 00:34:26.340
nicht mehr halten. Ja, das ist halt dann, ja.

00:34:28.000 --> 00:34:28.320
Ja.

00:34:29.860 --> 00:34:30.140
Aha.

00:34:30.400 --> 00:34:31.960
Ja, aber jetzt gehen wir, glaube ich, jetzt haben wir so ein bisschen

00:34:31.960 --> 00:34:33.660
generell darüber gesprochen, was so

00:34:33.660 --> 00:34:36.080
Python generell, was das so ausmacht.

00:34:36.420 --> 00:34:38.160
Jetzt gehen wir so ein bisschen tiefer in die

00:34:38.160 --> 00:34:40.060
Probleme der, oder was heißt

00:34:40.060 --> 00:34:41.980
die Probleme, die Ideen, die Konzepte der eigentlichen

00:34:41.980 --> 00:34:43.760
Sprache, was man auch vielleicht achten muss.

00:34:43.940 --> 00:34:46.020
Also, falls ihr noch Fragen habt, die ich nicht beantwortet hatte, schreibt uns

00:34:46.020 --> 00:34:48.380
wieder, wie immer, hallo at pythonpodcast.de

00:34:48.380 --> 00:34:49.960
Wofür ist die

00:34:49.960 --> 00:34:50.340
InitPy?

00:34:53.140 --> 00:34:54.060
Das ist eine gute Frage.

00:34:54.720 --> 00:34:55.940
Ja, man braucht das irgendwie,

00:34:56.220 --> 00:34:58.060
damit es ein

00:34:58.060 --> 00:34:58.720
Paket ist.

00:35:00.820 --> 00:35:01.940
Ein Modul, wo es

00:35:01.940 --> 00:35:03.480
Unterschied zwischen Modulen und Paketen? Oh mein Gott.

00:35:03.900 --> 00:35:05.560
Ich glaube, das muss ich ja selber nochmal nachlesen.

00:35:05.940 --> 00:35:07.740
Damit der Namespace irgendwie vernünftig

00:35:07.740 --> 00:35:09.800
zugegriffen werden kann. Also alles, was man da irgendwie reinpackt,

00:35:09.840 --> 00:35:11.740
das sitzt dann im Namespace dieses Moduls, wenn man

00:35:11.740 --> 00:35:12.900
es importiert, direkt drin.

00:35:13.880 --> 00:35:16.020
Irgendwie so. Und dann kann man da direkt aktiv

00:35:16.020 --> 00:35:17.920
drauf zugreifen. Aber die Frage ist halt, warum man

00:35:17.920 --> 00:35:19.340
das dann nicht mit den Submodulen macht.

00:35:19.940 --> 00:35:21.740
Du kannst das ja auch

00:35:23.020 --> 00:35:23.540
reinschreiben,

00:35:23.800 --> 00:35:25.940
was du exportieren willst, welche Symbole.

00:35:27.840 --> 00:35:28.400
Interessante Frage ist,

00:35:28.400 --> 00:35:29.500
kann man da auch Sachen ausschließen?

00:35:29.800 --> 00:35:31.820
Also dass ich zum Beispiel sage, ja, auch diesen Modul bitte nicht

00:35:31.820 --> 00:35:33.600
in den Namespace packen oder sowas?

00:35:35.620 --> 00:35:36.220
Also es kommt noch

00:35:36.220 --> 00:35:37.660
eine andere Frage von einem Hörer von uns, der

00:35:37.660 --> 00:35:39.860
wissen wollte, wie das dann überhaupt so funktioniert, dass man

00:35:39.860 --> 00:35:42.140
Module selber bauen kann. Ich glaube, das Einzige, was man machen muss,

00:35:42.160 --> 00:35:44.220
ist halt ein Folder importieren.

00:35:44.220 --> 00:35:45.920
Also indem man halt relativ

00:35:45.920 --> 00:35:48.120
Zugriff drauf hat und dann einfach sagen

00:35:48.120 --> 00:35:50.120
Import Foldername

00:35:50.120 --> 00:35:52.140
oder sowas und wenn da eine Inispy drin ist, dann

00:35:52.140 --> 00:35:54.320
kann man die Module, die da drin sind, einfach

00:35:54.320 --> 00:35:56.220
aufrufen mit einem

00:35:56.220 --> 00:35:57.100
Import-Teil und dann kann man

00:35:57.100 --> 00:36:00.320
Modul, Verzeichnisname, Import, Python

00:36:00.320 --> 00:36:02.390
Datei oder from Modulname

00:36:02.390 --> 00:36:04.290
Punkt Python Datei, Import

00:36:04.290 --> 00:36:06.250
Funktionsname und dann kann man

00:36:06.250 --> 00:36:08.230
die einsetzen auf

00:36:08.230 --> 00:36:10.110
dieser lokalen Ebene. Und die Frage wäre halt jetzt,

00:36:10.450 --> 00:36:12.150
warum man diese initpy an der Stelle braucht

00:36:12.150 --> 00:36:14.350
und was die halt vielleicht macht und

00:36:14.350 --> 00:36:16.210
dass sie vielleicht halt dieses Namespacing,

00:36:16.350 --> 00:36:18.130
was in Python auch irgendwie so ein Ding ist, also

00:36:18.130 --> 00:36:20.470
zum Beispiel zu sagen, welcher Name

00:36:20.470 --> 00:36:21.990
jetzt zu welcher Funktion, zu welcher

00:36:21.990 --> 00:36:23.430
Sublibrary gehört,

00:36:24.070 --> 00:36:25.630
dass das da ein bisschen definiert wird.

00:36:26.550 --> 00:36:28.470
Ja, man kann auf jeden Fall an der Stelle kontrollieren,

00:36:28.870 --> 00:36:29.750
was halt

00:36:29.750 --> 00:36:32.630
eben, was mit welchem Namen

00:36:32.630 --> 00:36:33.830
exportiert werden soll, sozusagen.

00:36:34.790 --> 00:36:35.030
Und

00:36:35.030 --> 00:36:38.370
dafür ist es ganz nützlich. Warum man sie unbedingt braucht,

00:36:38.430 --> 00:36:40.170
weiß ich nicht so genau. Und das ist auch etwas, was

00:36:40.170 --> 00:36:42.630
mir schon öfter mal auf den Fuß gefallen

00:36:42.630 --> 00:36:44.130
ist und wahrscheinlich vielen Leuten, die jetzt,

00:36:44.710 --> 00:36:46.410
dass man halt, kriegt manchmal so

00:36:46.410 --> 00:36:48.170
wenig hilfreiche Fehlermeldungen, wenn man

00:36:48.170 --> 00:36:49.990
die Init-Py vergisst,

00:36:50.570 --> 00:36:52.450
sozusagen. Oder wenn die aus irgendwelchen Gründen abhanden

00:36:52.450 --> 00:36:53.870
gekommen ist, was ja auch manchmal vorkommen kann.

00:36:54.330 --> 00:36:56.410
Und dann kriegt man Tracebacks, die sehen

00:36:56.410 --> 00:36:58.110
irgendwie komisch aus. Und man

00:36:58.110 --> 00:37:00.250
sieht den nicht sofort an, dass da eine Input-Wire

00:37:00.250 --> 00:37:02.050
fehlt. Irgendwann weiß man halt einfach so,

00:37:02.110 --> 00:37:04.010
ah, das sieht jetzt danach aus, okay, das könnte sein,

00:37:04.070 --> 00:37:05.670
dass da einfach eine Input-Wire fehlt, aber...

00:37:05.670 --> 00:37:07.990
Ich hab zehn Minuten da vor meinem Bildschirm gestanden und überlegt,

00:37:08.070 --> 00:37:09.930
warum macht der jetzt nicht die Migrationen von

00:37:09.930 --> 00:37:12.110
meinem Dankmodell, den ich da geschrieben habe, verstehe ich nicht.

00:37:12.610 --> 00:37:14.230
Und dann fehlte einfach die Input-Wire, Migrations-

00:37:14.230 --> 00:37:16.050
Bruder und dann, ach so, ja klar, kennt der ja nicht,

00:37:16.110 --> 00:37:16.770
kann der ja gar nicht sehen.

00:37:17.970 --> 00:37:20.010
Aber da muss man auch drauf kommen, tatsächlich, sonst...

00:37:20.010 --> 00:37:22.170
Ja, das ist so ein bisschen...

00:37:22.170 --> 00:37:24.030
Genau, und eben, ja, also gute

00:37:24.030 --> 00:37:26.130
Idee

00:37:26.130 --> 00:37:27.990
mit, was sind eigentlich Paketemodule

00:37:27.990 --> 00:37:29.790
wie funktioniert eigentlich ein Port-System?

00:37:29.930 --> 00:37:31.930
Da müssen wir uns auch nochmal beschäftigen, aber da

00:37:31.930 --> 00:37:34.350
müsste ich mich auch erstmal anlesen. Das weiß ich jetzt alles gar nicht so genau.

00:37:35.170 --> 00:37:36.150
Ja, das kriegen wir bestimmt noch

00:37:36.150 --> 00:37:37.970
jeden Tag. Aber wir haben ja die Minute schon wieder überschritten.

00:37:38.570 --> 00:37:38.930
Ah ja, gut.

00:37:39.750 --> 00:37:42.170
Aber Inipi ist ja immer mit dann, dann, also doppelt

00:37:42.170 --> 00:37:44.030
Underscore am Anfang und am Ende. Also wofür brauchen wir

00:37:44.030 --> 00:37:45.730
überhaupt ein Underscore und wofür zwei?

00:37:47.330 --> 00:37:48.050
Ja, also ich glaube,

00:37:48.190 --> 00:37:49.270
das ist...

00:37:49.270 --> 00:37:51.630
Also die Konvention ist das.

00:37:52.410 --> 00:37:54.030
Ich glaube, früher war es mal

00:37:54.030 --> 00:37:55.790
nicht nur eine Konvention, aber mittlerweile ist es tatsächlich

00:37:55.790 --> 00:37:57.890
nur Konvention, dass man Sachen, die halt

00:37:57.890 --> 00:37:59.470
innerhalb einer

00:37:59.470 --> 00:38:02.290
Klasse oder innerhalb

00:38:02.290 --> 00:38:04.470
also Dinge, die halt sozusagen

00:38:04.470 --> 00:38:06.090
private API sind oder privat

00:38:06.090 --> 00:38:08.070
benutzt werden, aber nicht nach außen

00:38:08.070 --> 00:38:10.010
eigentlich nicht von außen

00:38:10.010 --> 00:38:12.390
benutzt, also

00:38:12.390 --> 00:38:14.370
angefasst werden sollten, die

00:38:14.370 --> 00:38:15.990
werden halt mit Doppel

00:38:15.990 --> 00:38:18.170
und Underscore halt irgendwie gepräfixt

00:38:18.170 --> 00:38:20.090
und Sachen, die halt

00:38:20.090 --> 00:38:20.830
sozusagen

00:38:20.830 --> 00:38:24.270
dann gibt es einfach ein Underscore, das ist halt

00:38:24.270 --> 00:38:26.070
so markiert

00:38:26.070 --> 00:38:26.730
für

00:38:26.730 --> 00:38:37.770
Aber ja, also sollte man nicht, ist auch eher so interner Gebrauch, aber ist jetzt nicht so total privat.

00:38:40.110 --> 00:38:51.370
Ja, also ist es eine Konvention. Im Grunde braucht man das auch, also außer jetzt manchmal bei Double Underscore, eigentlich auch nicht wirklich.

00:38:52.550 --> 00:38:54.310
Also ich habe zum Beispiel diese internen Variablen

00:38:54.310 --> 00:38:56.250
noch nicht verstanden, wofür das gut ist.

00:38:56.270 --> 00:38:57.750
Ich habe es auch noch nie benutzt, außer jetzt

00:38:57.750 --> 00:39:00.310
im Magic-Method-Kontext von

00:39:00.310 --> 00:39:02.410
Klassen, wo man halt dann irgendwelche magischen

00:39:02.410 --> 00:39:04.250
Methoden, die es identifiziert, überschreiben will, um

00:39:04.250 --> 00:39:05.250
andere Effekte zu erzeugen.

00:39:06.490 --> 00:39:07.790
Ja, es ist halt so ein

00:39:07.790 --> 00:39:10.390
Hinweis darauf, dass man

00:39:10.390 --> 00:39:11.090
da nicht

00:39:11.090 --> 00:39:14.270
wirklich mit interagieren

00:39:14.270 --> 00:39:16.210
sollte. Nicht umfassen, fast, meine Klasse

00:39:16.210 --> 00:39:18.270
nicht. Alles, was man selber schreibt,

00:39:18.330 --> 00:39:19.970
machen immer anders, bevor damit eigentlich niemand anderes

00:39:19.970 --> 00:39:22.390
anfasst. Nee, nee, ich versuche

00:39:22.390 --> 00:39:23.890
mal ein Beispiel zu geben. Also wenn du

00:39:23.890 --> 00:39:26.190
eine Klasse hast, die irgendwas casht, dann

00:39:26.190 --> 00:39:27.190
packst du halt

00:39:27.190 --> 00:39:30.370
wenn, also du rechnest

00:39:30.370 --> 00:39:32.010
das halt aus, du überprüfst in der Methode, ja,

00:39:32.130 --> 00:39:33.690
sozusagen ein bestimmtes Attribut

00:39:33.690 --> 00:39:36.390
ist eine Property von dieser Klasse,

00:39:36.550 --> 00:39:38.290
also hat ein Property-Dekorator drüber, irgendwas

00:39:38.290 --> 00:39:40.350
wird ausgerechnet und du

00:39:40.350 --> 00:39:42.330
schreibst das Ergebnis dieser Berechnung, also prüfst

00:39:42.330 --> 00:39:44.270
wenn du die Methode aufrufst, zuerst habe ich

00:39:44.270 --> 00:39:46.230
das schon ausgerechnet, wenn ja,

00:39:46.310 --> 00:39:47.090
gibst du einfach das

00:39:47.090 --> 00:39:49.970
gecashten Wert zurück

00:39:49.970 --> 00:39:52.070
und ansonsten rechnest du es halt neu aus,

00:39:52.150 --> 00:39:53.930
unter bestimmten Bedingungen.

00:39:54.290 --> 00:39:54.570
Und

00:39:54.570 --> 00:39:58.230
den Cache selber, den legt man

00:39:58.230 --> 00:40:00.050
oft dann in so eine Underscore irgendwie

00:40:00.050 --> 00:40:01.670
Attribut ab. Underscore Cache.

00:40:02.070 --> 00:40:03.370
Ja, oder Underscore

00:40:03.370 --> 00:40:05.990
dieses, dieser Name, dieses

00:40:05.990 --> 00:40:07.390
Attributes oder so, weil

00:40:07.390 --> 00:40:10.010
und das heißt halt ja bitte nicht anfassen,

00:40:10.090 --> 00:40:11.890
weil das Problem ist jetzt, wenn ich von außen da rangehe,

00:40:11.950 --> 00:40:13.910
dann kriege ich vielleicht den gecacheten Wert, aber ich

00:40:13.910 --> 00:40:15.750
kenne ja jetzt gar nicht die Bedingungen, unter denen das

00:40:15.750 --> 00:40:17.790
vielleicht, ich denke, Cache invalidieren

00:40:17.790 --> 00:40:19.630
müsste oder so. Und wenn ich da jetzt einfach so drauf

00:40:19.630 --> 00:40:20.910
zugreife, dann

00:40:20.910 --> 00:40:23.910
kann sein, dass Dinge schief

00:40:23.910 --> 00:40:25.090
gehen. Und

00:40:25.090 --> 00:40:27.990
das heißt, ja, das ist halt so eine Markierung

00:40:27.990 --> 00:40:29.830
für, das Ding hier bitte nicht

00:40:29.830 --> 00:40:31.810
direkt verwenden, sondern, ne, dann gibt's

00:40:31.810 --> 00:40:34.190
ja meistens ein öffentliches

00:40:34.190 --> 00:40:35.410
Attribut, was man

00:40:35.410 --> 00:40:37.990
benutzen kann und dann kann die Klasse das intern

00:40:37.990 --> 00:40:38.610
handeln, wie sie das integriert.

00:40:38.610 --> 00:40:40.510
Was ist denn überhaupt eine API?

00:40:43.550 --> 00:40:43.910
Ja,

00:40:44.010 --> 00:40:45.170
im Grunde eine Schnittstelle,

00:40:45.490 --> 00:40:47.350
die Schnittstelle zu irgendwas.

00:40:47.830 --> 00:40:49.330
Das gibt's jetzt auch in unterschiedlichen

00:40:49.330 --> 00:40:52.050
Kontexten kann man das

00:40:52.050 --> 00:40:53.650
verwenden, aber ich würde jetzt mal sagen, also

00:40:53.650 --> 00:40:55.530
üblicherweise, wenn man jetzt irgendein Paket

00:40:55.530 --> 00:40:57.570
verwendet,

00:40:58.010 --> 00:41:00.190
weiß ich nicht, Party-Django-Paket

00:41:00.190 --> 00:41:01.750
oder irgendeine Python-Bibliothek oder so,

00:41:02.210 --> 00:41:04.050
dann ist die API das, was

00:41:04.050 --> 00:41:05.710
man sozusagen von außen benutzt.

00:41:06.310 --> 00:41:08.090
Die besteht ja aus ganz vielen Funktionen.

00:41:08.290 --> 00:41:09.950
Befehle, die man für seine Bibliothek benutzen

00:41:09.950 --> 00:41:11.130
kann, um die

00:41:11.130 --> 00:41:13.570
für den Anwendungsfall...

00:41:13.570 --> 00:41:15.730
Also wenn ich jetzt zum Beispiel jetzt Requests nehme

00:41:15.730 --> 00:41:17.590
oder so, dann macht

00:41:17.590 --> 00:41:19.790
Request.get macht halt ein Get-Request, das ist halt

00:41:19.790 --> 00:41:21.890
der öffentliche. Intern macht das dann

00:41:21.890 --> 00:41:24.010
unter Umständen noch eine ganze Menge anderer Funktionsaufrufe

00:41:24.010 --> 00:41:25.690
und Dinge und weißer Teufel.

00:41:25.990 --> 00:41:27.730
Und die sind aber intern gar nicht alle

00:41:27.730 --> 00:41:29.790
mit einem Underscore. Nö, also manche

00:41:29.790 --> 00:41:31.830
von denen kann ich auch einfach so verwenden, das wäre auch kein Problem,

00:41:32.070 --> 00:41:33.790
aber andere wahrscheinlich auch eher

00:41:33.790 --> 00:41:36.010
nicht. Und die, die ich nicht unbedingt verwenden sollte

00:41:36.010 --> 00:41:37.830
von außen, die sind halt dann

00:41:37.830 --> 00:41:38.690
so markiert als

00:41:38.690 --> 00:41:40.370
für intern gebraucht.

00:41:42.170 --> 00:41:43.990
Was ist eine private und eine globale

00:41:43.990 --> 00:41:45.850
Variable und was ist der Unterschied und wofür braucht man

00:41:45.850 --> 00:41:48.690
Global, privat, also privat

00:41:48.690 --> 00:41:50.630
öffentlich, das ist halt so ein bisschen, aber

00:41:50.630 --> 00:41:53.110
das hat man in Python eigentlich auch gar nicht so wahnsinnig

00:41:53.110 --> 00:41:54.650
viel, also es gibt es in anderen Programmiersprachen

00:41:54.650 --> 00:41:56.650
gibt es da eine stärkere

00:41:56.650 --> 00:41:58.750
Unterscheidung, aber also im Grunde

00:41:58.750 --> 00:42:00.350
ist es einfach so. Also ich hatte es gerade so in den ganz

00:42:00.350 --> 00:42:02.710
Anfängertagen ganz oft so, dass ich irgendwie mir dachte

00:42:02.710 --> 00:42:04.710
so ja, private Variablen, das ist

00:42:04.710 --> 00:42:06.610
alles irgendwie ein bisschen blöd, ich muss ja irgendwie von der Funktion

00:42:06.610 --> 00:42:08.650
immer irgendwie so einen Wert returnen und damit das dann

00:42:08.650 --> 00:42:10.670
also ich glaube im Kontext einer Funktion sind ja die eigentlich

00:42:10.670 --> 00:42:12.690
die Variablen immer privat. Nein, nein, nein,

00:42:12.690 --> 00:42:14.430
nee, das ist eine Verwechslung, also du meinst

00:42:14.430 --> 00:42:16.170
lokal und global.

00:42:16.750 --> 00:42:18.730
Privat und öffentlich, das ist

00:42:18.730 --> 00:42:20.530
halt genau diese Geschichte mit dem Double Undersquad.

00:42:20.610 --> 00:42:22.590
Ja, okay. Dann meinte ich lokal

00:42:22.590 --> 00:42:24.550
und global, ja. Also

00:42:24.550 --> 00:42:26.750
lokal heißt, Variablen sind halt

00:42:26.750 --> 00:42:28.630
quasi in dem

00:42:28.630 --> 00:42:29.030
Block

00:42:29.030 --> 00:42:31.270
gültig.

00:42:33.270 --> 00:42:34.910
Und ich

00:42:34.910 --> 00:42:36.810
habe immer gehört, man braucht keine globalen, man darf

00:42:36.810 --> 00:42:38.730
die nicht nehmen, dass das total nicht so backrest ist.

00:42:38.810 --> 00:42:40.790
Kann man schon. An einigen Stellen habe ich halt

00:42:40.790 --> 00:42:42.770
gemerkt, also gerade ich habe mal so Spielereien gemacht,

00:42:42.850 --> 00:42:44.850
Spiele gebaut oder sowas. Da hat es immer total

00:42:44.850 --> 00:42:47.090
super geholfen, weiß ich nicht, die Lebensenergie

00:42:47.090 --> 00:42:48.730
des kleinen Männchens global

00:42:48.730 --> 00:42:50.670
zu definieren, anstatt in einer Funktion oder so.

00:42:51.590 --> 00:42:52.670
Jaja, kann man

00:42:52.670 --> 00:42:54.730
durchaus machen. Es gibt auch Fälle, wo man das

00:42:54.730 --> 00:42:55.690
durchaus

00:42:55.690 --> 00:42:58.730
praktische Anwendungsfälle

00:42:58.730 --> 00:42:58.950
hat.

00:43:00.310 --> 00:43:02.490
Ist jetzt nicht unbedingt immer so gut. Also es kommt halt

00:43:02.490 --> 00:43:03.890
darauf an, was man damit machen möchte.

00:43:06.010 --> 00:43:06.710
Man muss das

00:43:06.710 --> 00:43:08.530
halt explizit halt dann als

00:43:08.530 --> 00:43:10.550
global markieren, wenn man das tun möchte. Und dann gibt es

00:43:10.550 --> 00:43:11.790
auch, glaube ich, nochmal einen Unterschied zwischen

00:43:11.790 --> 00:43:14.390
nur global oder global für ein

00:43:14.390 --> 00:43:15.250
Modul oder

00:43:15.250 --> 00:43:16.750
aber

00:43:16.750 --> 00:43:20.350
ja, also für manche Sachen ist das

00:43:20.350 --> 00:43:22.310
durchaus, also gerade irgendwelche Konstanten

00:43:22.310 --> 00:43:24.270
oder so, die definiert werden, die sind oft global.

00:43:25.290 --> 00:43:26.310
Also wenn man das nicht ändert,

00:43:26.350 --> 00:43:28.470
ist das ja auch nicht schlimm. Wenn man jetzt globale

00:43:28.470 --> 00:43:30.170
Variablen hat, die man ändert, dann

00:43:30.170 --> 00:43:30.870
ist so ein bisschen

00:43:30.870 --> 00:43:34.190
das riecht dann schon so ein bisschen danach,

00:43:34.190 --> 00:43:36.010
als ob da irgendwas nicht so richtig ordentlich

00:43:36.010 --> 00:43:36.750
funktioniert, weil

00:43:36.750 --> 00:43:39.850
was

00:43:39.850 --> 00:43:42.170
möchte man damit eigentlich machen? Also man hat

00:43:42.170 --> 00:43:44.150
da irgendwie State, auf den man zugreift

00:43:44.150 --> 00:43:46.090
von unterschiedlichen Stellen. Also es wird dann halt sehr schwer zu

00:43:46.090 --> 00:43:48.110
debuggen und sehr schwer vorauszusagen,

00:43:48.190 --> 00:43:49.970
was da eigentlich passiert, wenn man das einfach so verwendet

00:43:49.970 --> 00:43:51.810
in unterschiedlichen Stellen des Codes.

00:43:52.590 --> 00:43:53.870
Das dann ändert einfach so.

00:43:54.090 --> 00:43:55.850
Da muss man sich halt sehr, sehr genau überlegen

00:43:55.850 --> 00:43:57.610
oder man muss halt, also

00:43:57.610 --> 00:43:59.670
vielleicht fange ich so rum an.

00:43:59.970 --> 00:44:01.810
Das Problem beim Programmieren ist dann halt irgendwie,

00:44:01.910 --> 00:44:03.670
dass ich an der Stelle, wo ich das ändere,

00:44:04.150 --> 00:44:05.670
muss mir ja immer klar sein,

00:44:06.970 --> 00:44:07.850
was an allen anderen

00:44:07.850 --> 00:44:09.390
Stellen im Code,

00:44:09.610 --> 00:44:11.810
an diesem Ding irgendwie rumgeschraubt wird, auch passiert.

00:44:12.330 --> 00:44:13.890
Warum? Also ich nehme jetzt mal

00:44:13.890 --> 00:44:15.910
so ein Beispiel, wo ich jetzt intuitiv sagen würde,

00:44:16.010 --> 00:44:17.750
das wäre jetzt für mich das, was ich jetzt

00:44:17.750 --> 00:44:19.730
als globale Variable haben würde. Ich habe

00:44:19.730 --> 00:44:22.050
jetzt ein Spiel, mein Barbar hat Lebensenergie

00:44:22.050 --> 00:44:23.710
von 100. Und es gibt

00:44:23.710 --> 00:44:25.690
bestimmte Funktionen, die aufgerufen werden, wenn der

00:44:25.690 --> 00:44:27.690
Barbar irgendwas macht, falsch macht, richtig macht,

00:44:27.770 --> 00:44:29.850
runterfällt, gegen einen anderen, gegen einen Monster kämpft,

00:44:30.330 --> 00:44:31.630
dann würde ich von dieser

00:44:31.630 --> 00:44:33.250
globalen Lebensenergie irgendwas abziehen.

00:44:34.450 --> 00:44:34.570
Ja.

00:44:35.830 --> 00:44:37.670
Wofür muss ich denn dann an der einen Stelle,

00:44:37.770 --> 00:44:39.510
wenn er jetzt, weiß ich nicht, auf ein Skelett trifft,

00:44:39.810 --> 00:44:41.050
dem Zehn Lebensenergie abzieht,

00:44:41.370 --> 00:44:43.810
wissen, was an einer anderen Stelle die Falle mit ihm gemacht hat.

00:44:46.570 --> 00:44:50.310
Naja, also weil du, weil ja, naja, lass mal überlegen.

00:44:50.450 --> 00:44:53.870
Kann ich irgendwas konstruieren, was dann problematisch wird?

00:44:54.190 --> 00:44:55.270
Ich meine, es kann ja auch Dinge geben,

00:44:55.350 --> 00:44:56.510
die die Lebensenergie wieder erhöhen.

00:44:57.330 --> 00:44:57.790
Ein Trank.

00:44:58.070 --> 00:44:59.030
Ja, und du musst halt zum Beispiel,

00:44:59.810 --> 00:45:00.530
du musst halt wissen,

00:45:00.810 --> 00:45:03.030
dass das jetzt schon nicht unter Null gefallen ist,

00:45:03.030 --> 00:45:06.490
wenn du jetzt, sonst könntest du dich ja auch wieder lebendig machen,

00:45:07.350 --> 00:45:09.230
sozusagen, wenn du tot bist, eigentlich.

00:45:09.490 --> 00:45:10.510
Ein Lifehack, ja.

00:45:12.170 --> 00:45:13.550
Irgendwas muss diesen State verwalten.

00:45:13.670 --> 00:45:15.430
Irgendwas muss halt sagen, okay, jetzt bist du

00:45:15.430 --> 00:45:17.330
aber tot. Und dann darfst du nicht

00:45:17.330 --> 00:45:19.090
durch, darf nicht irgendein anderer Teil

00:45:19.090 --> 00:45:21.010
des Codes, der jetzt nicht weiß, ob du tot bist oder nicht,

00:45:21.630 --> 00:45:23.430
einfach deine Lebensenergie

00:45:23.990 --> 00:45:25.250
oder deine Lebenspunkte erhöhen,

00:45:25.390 --> 00:45:27.050
weil das macht dich ja eventuell wieder lebendig,

00:45:27.170 --> 00:45:28.590
in einer Situation, wo das gar nicht gehen darf.

00:45:30.330 --> 00:45:31.530
Also, sozusagen,

00:45:31.730 --> 00:45:33.450
es ist... Also, das würde nicht so

00:45:33.450 --> 00:45:35.010
gut funktionieren. Das heißt, da würde man auch auch

00:45:35.010 --> 00:45:37.190
klassenbasiert einen Ansatz nehmen, wo man irgendwie

00:45:37.190 --> 00:45:39.190
sowas machen wie erhöhe Lebenspunkte und reduziere

00:45:39.190 --> 00:45:41.030
Lebenspunkte und der macht das halt dann nur dann, wenn man

00:45:41.030 --> 00:45:43.170
noch nicht tot ist oder so. Genau, und das

00:45:43.170 --> 00:45:45.090
erhöhe Lebenspunkte geht halt nur, solange man nicht tot ist,

00:45:45.130 --> 00:45:46.450
zum Beispiel und so. Aber diese Logik,

00:45:46.810 --> 00:45:48.970
wie das funktioniert, wäre dann halt an einem

00:45:48.970 --> 00:45:51.010
Ort gebündelt. Das ist ja so ein bisschen die Idee

00:45:51.010 --> 00:45:51.630
auch hinter Klassen,

00:45:53.030 --> 00:45:55.070
überhaupt hinter Objektorientierter Programmierung,

00:45:55.150 --> 00:45:56.890
dass du halt die ganze Komplexität

00:45:56.890 --> 00:45:59.170
irgendwie verbirgst

00:45:59.170 --> 00:46:00.270
hinter

00:46:00.270 --> 00:46:02.610
ja, hinter dieser

00:46:02.610 --> 00:46:05.130
in diesem Objekt, hinter einer API.

00:46:05.650 --> 00:46:06.950
Genau, und dann das halt alles nicht mehr

00:46:06.950 --> 00:46:08.990
wissen musst. Während wenn du jetzt einfach nur eine Variable hast,

00:46:09.050 --> 00:46:10.050
die jeder irgendwie verändern kann,

00:46:10.950 --> 00:46:13.170
dann ist die Komplexität verteilt

00:46:13.170 --> 00:46:14.910
über den gesamten Code

00:46:14.910 --> 00:46:16.950
irgendwie, der mit dieser Variable interagiert.

00:46:17.110 --> 00:46:19.130
Was wäre denn jetzt aber ein cleveres Beispiel für eine globale

00:46:19.130 --> 00:46:20.890
Variable, wo man sagen würde, hey, da macht das

00:46:20.890 --> 00:46:21.650
irgendwie jetzt dann doch Sinn?

00:46:22.970 --> 00:46:25.030
Mir fällt da fast keins ein,

00:46:25.070 --> 00:46:25.930
wo das irgendwie sinnvoll ist.

00:46:26.650 --> 00:46:28.490
Was man manchmal hat, ist, dass man

00:46:28.490 --> 00:46:30.070
sicher sein möchte, dass

00:46:30.070 --> 00:46:32.170
man etwas nur

00:46:32.170 --> 00:46:34.430
einmal hat oder so. Aber da

00:46:34.430 --> 00:46:36.530
würde man auch eher ein Single nehmen,

00:46:36.610 --> 00:46:38.070
beziehungsweise in Python eher Borg-Pattern.

00:46:38.070 --> 00:46:39.490
Oh, Singleton, das steht hier ein bisschen weiter unten.

00:46:39.610 --> 00:46:42.030
Ein Singleton-Borg-Pattern, hast du gerade gesagt?

00:46:43.030 --> 00:46:43.450
Ja, okay.

00:46:44.230 --> 00:46:45.770
Was ist ein Singleton, was ist ein Borg-Pattern?

00:46:45.990 --> 00:46:46.570
Du musst wieder anfangen.

00:46:48.030 --> 00:46:54.910
Also sozusagen, Singleton ist, wenn garantiert sein soll,

00:46:55.010 --> 00:46:57.010
dass es von einer bestimmten Geschichte nur eine Instanz gibt.

00:46:57.010 --> 00:47:04.010
Also wenn ich zum Beispiel eben in einem Spiel die Spielfigur

00:47:04.010 --> 00:47:05.310
oder so, die dann bestimmte Eigenschaften hat,

00:47:05.690 --> 00:47:07.010
eben sowas wie Lebensenergie oder so,

00:47:07.850 --> 00:47:09.470
wenn ich garantieren möchte, dass alle,

00:47:09.690 --> 00:47:11.570
die damit interagieren, immer die gleiche Instanz sehen.

00:47:11.810 --> 00:47:13.570
Dass ich halt den nicht, weil es gibt nur einen

00:47:13.570 --> 00:47:15.470
und es wäre jetzt blöd, wenn ich zwei davon erzeuge und dann

00:47:15.470 --> 00:47:16.830
in dem einen Objekt

00:47:16.830 --> 00:47:19.610
verlinke ich die Lebensenergie und beim anderen nicht oder so.

00:47:19.690 --> 00:47:21.450
Wie macht man das denn? Überschreibt man dann die New-Methode

00:47:21.450 --> 00:47:23.450
und sagt dann so, nee, wenn es schon eins gibt, dann mach keinen neuen?

00:47:24.330 --> 00:47:25.550
Naja, das ist, nee,

00:47:25.690 --> 00:47:26.930
eigentlich, also so, weil

00:47:26.930 --> 00:47:29.590
dann kommen wir zum Borg-Python, so wird das üblicherweise dann in Python

00:47:29.590 --> 00:47:31.590
implementiert, ist, man macht

00:47:31.590 --> 00:47:32.530
es einfach so, dass

00:47:32.530 --> 00:47:34.450
jetzt muss ich mal,

00:47:35.090 --> 00:47:37.130
wie ging das da? Also ich glaube, der Trick

00:47:37.130 --> 00:47:39.310
ist, aber das muss man mal nachgucken,

00:47:39.470 --> 00:47:40.450
also mit Vorsicht genießen,

00:47:41.970 --> 00:47:43.050
ist, dass

00:47:43.050 --> 00:47:44.970
sozusagen den State

00:47:44.970 --> 00:47:47.030
innerhalb von der,

00:47:47.950 --> 00:47:49.170
eines Objekts sozusagen

00:47:49.170 --> 00:47:51.290
in der Klassenvariable zu halten,

00:47:51.430 --> 00:47:52.870
die halt bei allen Instanzen gleich ist.

00:47:53.210 --> 00:47:55.090
Und dann können die Instanzen zwar unterschiedlich sein,

00:47:55.090 --> 00:47:55.950
aber der State ist immer gleich.

00:47:57.250 --> 00:47:59.030
Und dann ist es zwar kein

00:47:59.030 --> 00:48:00.470
Singleton in dem Sinne, wie

00:48:00.470 --> 00:48:02.970
wie man das vielleicht ursprünglich mal so definiert hat.

00:48:03.090 --> 00:48:05.750
Im Gänger-Vorbuch gibt es halt das Pattern Singleton,

00:48:06.770 --> 00:48:08.810
weil man eben nicht immer tatsächlich,

00:48:09.050 --> 00:48:11.170
also ich glaube, bei ursprünglichen Singleton-Beschreibungen

00:48:11.170 --> 00:48:14.930
ist es so, das wird einfach immer die gleiche Instanz returnt,

00:48:14.950 --> 00:48:15.990
wenn man halt die...

00:48:15.990 --> 00:48:16.950
Also das heißt nie überschreiben.

00:48:17.110 --> 00:48:18.670
Das würde halt bedeuten, wenn es schon ein anderes gibt,

00:48:18.770 --> 00:48:19.530
dann returnt es halt das.

00:48:20.950 --> 00:48:21.850
Returnt so das alte halt.

00:48:22.190 --> 00:48:23.790
Sowas kann man auch in Python machen, das wäre kein Problem,

00:48:23.930 --> 00:48:25.710
aber praktischer ist es halt, weil es einfach weniger Code

00:48:25.710 --> 00:48:28.590
und macht sozusagen, verhält sich ähnlich

00:48:28.590 --> 00:48:30.010
und hat noch ein paar andere nette Vorteile.

00:48:30.470 --> 00:48:33.110
dass du halt sozusagen sagst, der State

00:48:33.110 --> 00:48:36.890
bleibt über alle Instanzen

00:48:36.890 --> 00:48:39.510
von diesem Objekt gleich und ich muss da nicht kompliziert

00:48:39.510 --> 00:48:41.730
irgendwie dafür sorgen, dass ich immer die gleiche Instanz zurückgebe, weil

00:48:41.730 --> 00:48:42.730
wen interessiert es?

00:48:44.610 --> 00:48:47.690
Ja, aber genau, das sind alles,

00:48:48.330 --> 00:48:50.350
es geht immer so um State Handling im Grunde, das ist immer so,

00:48:50.710 --> 00:48:53.870
und wer manipuliert den und wie kann man dafür sorgen,

00:48:53.870 --> 00:48:55.250
dass man

00:48:55.250 --> 00:48:59.710
den Code, der den State manipuliert, an einer Stelle behält

00:48:59.710 --> 00:49:01.750
und so und nicht, weil das sind immer so

00:49:01.750 --> 00:49:03.250
das ist was, was halt man am Anfang

00:49:03.250 --> 00:49:05.050
das ist ein bisschen unintuitiv, das

00:49:05.050 --> 00:49:07.830
denkt man sich so, naja, das ist ja kein Problem

00:49:07.830 --> 00:49:09.530
State kann irgendwo sein, egal

00:49:09.530 --> 00:49:11.750
ist in einer Variable, in einer globalen Variable

00:49:11.750 --> 00:49:13.510
oder so oder halt auch

00:49:13.510 --> 00:49:15.770
oft verteilt oder man hat

00:49:15.770 --> 00:49:17.750
die Klassen, sich mal irgendwie überlegt, wie

00:49:17.750 --> 00:49:19.670
so eine Klassenhierarchie aussehen soll

00:49:19.670 --> 00:49:20.410
oder so, aber

00:49:20.410 --> 00:49:23.750
zieht das dann durch, unabhängig davon, wie das Problem

00:49:23.750 --> 00:49:25.030
eigentlich ist und

00:49:25.030 --> 00:49:27.590
das fiese, was manchmal dann

00:49:27.590 --> 00:49:28.950
oder fast immer passiert, irgendwie

00:49:28.950 --> 00:49:31.170
ist, dass man dann halt den State verteilt

00:49:31.170 --> 00:49:32.390
über viel Code.

00:49:32.870 --> 00:49:33.810
Was ist überhaupt State?

00:49:35.650 --> 00:49:37.090
Das, was du

00:49:37.090 --> 00:49:38.990
speichern musst, was sich

00:49:38.990 --> 00:49:39.550
irgendwie ändert.

00:49:41.150 --> 00:49:42.070
Der Status.

00:49:44.530 --> 00:49:44.930
Also

00:49:44.930 --> 00:49:46.950
sagen wir mal so, bei einer Web-Applikation würde

00:49:46.950 --> 00:49:49.150
man sagen, das ist der State einer Web-Applikation,

00:49:49.250 --> 00:49:50.830
liegt üblicherweise dann eben in der Datenbank.

00:49:52.190 --> 00:49:52.950
Das ist so einer klassischen

00:49:52.950 --> 00:49:54.070
Datenbank.

00:49:54.070 --> 00:49:56.050
Was bedeutet das? Also was ist

00:49:56.050 --> 00:49:57.950
denn überhaupt dann der State? Sagt

00:49:57.950 --> 00:49:59.810
der, wie der

00:49:59.810 --> 00:50:01.710
Nutzer gerade aussehen soll, wie der heißt

00:50:01.710 --> 00:50:03.870
und was er für Daten gespeichert

00:50:03.870 --> 00:50:05.790
hat für sein Profil, was

00:50:05.790 --> 00:50:07.690
er sehen soll. Und das ist halt nicht dynamisch

00:50:07.690 --> 00:50:09.370
generiert, sondern das liegt dann irgendwo rum.

00:50:10.750 --> 00:50:11.790
Das heißt, wenn man das ändern

00:50:11.790 --> 00:50:13.710
möchte, dann muss man erst die Daten anfragen oder so was.

00:50:13.730 --> 00:50:15.070
Das macht man dann gar nicht woanders.

00:50:16.970 --> 00:50:17.510
Ja, genau.

00:50:17.850 --> 00:50:17.970
Also

00:50:17.970 --> 00:50:23.750
das, was halt sozusagen

00:50:23.750 --> 00:50:25.910
beschreibt, in welchem Zustand

00:50:25.910 --> 00:50:26.830
deine Applikation ist.

00:50:27.130 --> 00:50:29.270
Gehen wir jetzt nochmal aufs Spiel kurz, also was

00:50:29.270 --> 00:50:31.350
mit der Figur ist, was hat die gerade für eine Waffe

00:50:31.350 --> 00:50:33.310
in der Hand, was für Lebensenergie hat die, wie viel

00:50:33.310 --> 00:50:34.750
Rüstung hat die noch an, das wäre der State.

00:50:35.070 --> 00:50:37.350
Genau, dann gehst du irgendwo in einen virtuellen

00:50:37.350 --> 00:50:39.470
Laden und kaufst dir irgendwie das magische

00:50:39.470 --> 00:50:41.250
sonst was Schwert, Feuerschwert, mit dem

00:50:41.250 --> 00:50:43.190
du irgendwie alle platt machen kannst, dann muss

00:50:43.190 --> 00:50:45.230
ja irgendwo gespeichert werden, dass du das jetzt

00:50:45.230 --> 00:50:47.230
hast, dass das deine Adventure ist. Und ich darf aber auch

00:50:47.230 --> 00:50:49.250
keine zwei gleichzeitigen Sachen dann irgendwie

00:50:49.250 --> 00:50:51.130
haben, also damit das sich jetzt nicht widerspricht, darf es immer noch

00:50:51.130 --> 00:50:53.170
ein State geben, das so das, was

00:50:53.170 --> 00:50:54.950
dahinter steckt. Die interessante Frage ist, wie

00:50:54.950 --> 00:50:56.990
verwaltet man diesen State?

00:50:57.130 --> 00:50:58.950
sozusagen. Und

00:50:58.950 --> 00:51:01.330
naiv

00:51:01.330 --> 00:51:03.450
wäre halt, man hat

00:51:03.450 --> 00:51:05.330
halt zum Beispiel, Held da ist halt in irgendwelchen

00:51:05.330 --> 00:51:07.190
globalen Variablen. Man hat halt eine Liste,

00:51:07.570 --> 00:51:08.810
die ist halt global,

00:51:09.370 --> 00:51:10.710
genau, da steht halt drin,

00:51:11.710 --> 00:51:13.270
ja, hier ist halt das Flammenschwert

00:51:13.270 --> 00:51:15.190
und das ist da jetzt in dieser Liste der

00:51:15.190 --> 00:51:17.270
Items drin. Und alle manipulieren

00:51:17.270 --> 00:51:19.430
diese Liste von Items irgendwie.

00:51:19.650 --> 00:51:21.310
Aber das macht dann halt Probleme,

00:51:21.450 --> 00:51:23.350
weil dann ist Logik, die jetzt

00:51:23.350 --> 00:51:25.450
irgendwie solche Sachen

00:51:25.450 --> 00:51:27.490
abbildet, wie das Flammenschmerz

00:51:27.490 --> 00:51:29.190
macht jetzt plus 10 Angriff, aber

00:51:29.190 --> 00:51:31.330
auf der anderen Seite wird dir heiß, das heißt

00:51:31.330 --> 00:51:33.350
wird dir die Hand heiß und

00:51:33.350 --> 00:51:35.550
du verlierst irgendwie alle halbe Stunde ein paar Lebenspunkte

00:51:35.550 --> 00:51:36.310
oder sowas, keine Ahnung.

00:51:38.290 --> 00:51:39.090
Das ist ja Code,

00:51:39.570 --> 00:51:41.730
der irgendwie diese Business-Logik,

00:51:41.730 --> 00:51:43.090
wenn man das so sagen kann, in dem Spiel

00:51:43.090 --> 00:51:45.450
halt implementiert und das kann ja sein, dass da

00:51:45.450 --> 00:51:47.310
unterschiedlicher Code an unterschiedlichen Stellen steht

00:51:47.310 --> 00:51:49.710
und wenn du jetzt überall das gleiche

00:51:49.710 --> 00:51:50.130
globale

00:51:50.130 --> 00:51:53.850
Variable hast,

00:51:53.970 --> 00:51:55.930
auf die du zugreifst, da musst du dafür sorgen,

00:51:56.030 --> 00:51:57.170
dass dieser gesamte Code, der halt

00:51:57.170 --> 00:51:59.510
über dein Projekt verteilt sein kann,

00:51:59.950 --> 00:52:01.970
dass der immer weiß, was alle anderen Sachen

00:52:01.970 --> 00:52:03.970
machen. Und das geht ab einer gewissen Größe nicht

00:52:03.970 --> 00:52:06.010
mehr. Am Anfang geht das, solange es alles sehr klein

00:52:06.010 --> 00:52:07.910
ist, kriegt man das auch noch hin, dass man

00:52:07.910 --> 00:52:09.990
das alles im Kopf behält. Ja, du musst halt jedes Mal zumindest

00:52:09.990 --> 00:52:11.810
diese Überprüfung machen. Du musst halt jedes Mal gucken,

00:52:11.890 --> 00:52:13.890
hat denn jemand irgendwas geändert an der Stelle, das nicht sein

00:52:13.890 --> 00:52:15.610
darf. Das heißt, jede dieser Logiken müsstest du

00:52:15.610 --> 00:52:17.990
bei jeder Stelle, wo

00:52:17.990 --> 00:52:19.730
diese globale Variable geändert wird,

00:52:20.010 --> 00:52:22.170
erneut machen, was halt dem Don't Repeat Yourself

00:52:22.170 --> 00:52:23.270
widerspricht und so.

00:52:23.970 --> 00:52:26.470
das kann schon durchaus so sein,

00:52:26.610 --> 00:52:28.010
dass man sich da nicht wiederholt, aber

00:52:28.010 --> 00:52:30.350
du kannst halt Änderungen machen,

00:52:30.430 --> 00:52:31.990
die dann nicht lokale Auswirkungen haben.

00:52:33.030 --> 00:52:34.310
Also nehmen wir an, du weißt das halt alles

00:52:34.310 --> 00:52:36.330
nicht. Du machst jetzt halt ein neues

00:52:36.330 --> 00:52:38.310
Item, sozusagen, das irgendwelche

00:52:38.310 --> 00:52:40.290
Spezialgeschichten hat, schreibst da Code für,

00:52:40.450 --> 00:52:41.290
dass das halt irgendwie tut

00:52:41.290 --> 00:52:44.090
und dabei bedenkst du aber nicht,

00:52:44.270 --> 00:52:46.250
dass unter bestimmten Umständen

00:52:46.250 --> 00:52:47.770
irgendwelche Anarchoid irgendwas anderes tut.

00:52:47.770 --> 00:52:49.530
Und dann passieren halt Fehler

00:52:49.530 --> 00:52:51.650
und seltsame Effekte und

00:52:51.650 --> 00:52:53.750
solange man halt von dem

00:52:53.750 --> 00:52:55.790
ganzen anderen Code, der irgendwie daran rummanipuliert

00:52:55.790 --> 00:52:57.550
irgendwie weiß, ist das ja okay, aber

00:52:57.550 --> 00:52:59.830
sobald das Projekt irgendwie größer wird, geht das

00:52:59.830 --> 00:53:01.050
irgendwann nicht mehr und dann

00:53:01.050 --> 00:53:03.770
kann man überhaupt nicht vorhersagen, was passieren

00:53:03.770 --> 00:53:04.990
wird, wenn man jetzt irgendwie

00:53:04.990 --> 00:53:08.010
Dinge ändert, wie man manipuliert

00:53:08.010 --> 00:53:09.630
irgendwas an den Lebenspunkten oder so und dann

00:53:09.630 --> 00:53:11.830
gibt es irgendwas anderes, was wiederum nochmal was anderes

00:53:11.830 --> 00:53:13.650
macht. Der Invincible

00:53:13.650 --> 00:53:15.610
Geist. Ja, und

00:53:15.610 --> 00:53:17.630
das Mittel dagegen ist halt,

00:53:17.710 --> 00:53:19.750
dass du eben nicht direkt

00:53:19.750 --> 00:53:21.910
die Daten pro anfasst,

00:53:21.910 --> 00:53:23.670
sondern, dass du sagst,

00:53:23.750 --> 00:53:27.250
okay, wir haben hier eine Klasse oder so

00:53:27.250 --> 00:53:30.870
und der ist, bündeln wir den State, also die Daten

00:53:30.870 --> 00:53:34.890
und die Logik, die jetzt irgendwas damit macht

00:53:34.890 --> 00:53:39.130
und haben da eine API nach außen, die öffentlich ist

00:53:39.130 --> 00:53:43.010
und können sozusagen immer überprüfen,

00:53:43.110 --> 00:53:44.470
dass alles ordentlich ist an einer Stelle.

00:53:46.310 --> 00:53:48.450
Ja, die Frage war, was ist ein Objekt in Python?

00:53:49.130 --> 00:53:50.210
Was ist ein Objekt in Python?

00:53:53.750 --> 00:53:57.050
Ich würde es jetzt mal sagen,

00:53:57.330 --> 00:53:58.510
das erklärt aber nicht viel,

00:53:59.410 --> 00:54:00.930
ist halt die Instanz,

00:54:01.610 --> 00:54:03.450
konkretisierte Instanz von

00:54:03.450 --> 00:54:05.050
irgendwie einer Klasse.

00:54:06.770 --> 00:54:07.090
Also

00:54:07.090 --> 00:54:09.490
in einer Klasse definiert man sozusagen

00:54:09.490 --> 00:54:10.510
irgendwie, ja,

00:54:13.230 --> 00:54:13.790
eben eine

00:54:13.790 --> 00:54:15.710
Zusammenfassung von irgendwie Code, der was

00:54:15.710 --> 00:54:17.510
tut und irgendwie Daten,

00:54:17.970 --> 00:54:19.470
die man irgendwie halten will und

00:54:19.470 --> 00:54:21.750
wenn man das jetzt, das ist halt sozusagen

00:54:21.750 --> 00:54:23.810
die Beschreibung

00:54:23.810 --> 00:54:24.650
und wenn man da jetzt daraus...

00:54:24.650 --> 00:54:26.810
Ich sag nicht so besonders an von dem Brot, der irgendeine

00:54:26.810 --> 00:54:29.850
Beschreibung von irgendwelchen Sachen...

00:54:29.850 --> 00:54:31.670
Ja, also man könnte das vielleicht

00:54:31.670 --> 00:54:33.650
also... Also ein Objekt

00:54:33.650 --> 00:54:35.570
ist ein Ding. Also ich glaube, in Python ist alles ein Ding

00:54:35.570 --> 00:54:37.250
oder ein Objekt, oder? Alles ein Objekt, ja.

00:54:37.790 --> 00:54:39.610
Also alles, was es in Python gibt, kann sich

00:54:39.610 --> 00:54:41.250
als Objekt darstellen. Also ein Objekt ist immer

00:54:41.250 --> 00:54:42.870
eine Instanz einer Klasse,

00:54:43.410 --> 00:54:45.290
wenn man das so sagt. Ja. Das heißt,

00:54:45.470 --> 00:54:47.510
alles, was ihr habt in Python, sind tatsächlich

00:54:47.510 --> 00:54:49.530
Instanzen von irgendwelchen Klassen, von irgendwelchen Dingen.

00:54:49.530 --> 00:54:51.650
Ja. Die nächste Frage

00:54:51.650 --> 00:54:53.550
war, was ist Self? Self ist immer

00:54:53.550 --> 00:54:55.250
das Objekt selbst, also wenn man in dem Objekt

00:54:55.250 --> 00:54:57.590
auch eine, ist eine Konvention sozusagen, dass man

00:54:57.590 --> 00:54:58.430
das so nennt, aber

00:54:58.430 --> 00:55:01.150
sehr sinnvoll, das so zu machen.

00:55:01.770 --> 00:55:03.510
Außer es gibt wiederum Spezialfälle, bei denen

00:55:03.510 --> 00:55:05.310
man das ein bisschen anders macht. Also wenn man

00:55:05.310 --> 00:55:09.610
eine Methode hat, also Methode ist nichts

00:55:09.610 --> 00:55:10.870
weiter als eine Funktion,

00:55:11.490 --> 00:55:13.910
die sozusagen an so ein

00:55:13.910 --> 00:55:14.370
so eine

00:55:14.370 --> 00:55:17.090
Instanz, an so ein Objekt gebunden ist.

00:55:18.270 --> 00:55:19.490
Und jetzt

00:55:19.490 --> 00:55:21.510
möchte man halt, um zum Beispiel auf die Daten,

00:55:21.510 --> 00:55:23.210
die man halten möchte, in so einem Objekt

00:55:23.210 --> 00:55:25.450
um da drauf zuzugreifen, muss man

00:55:25.450 --> 00:55:26.990
ja irgendwie sich selbst referenzieren können

00:55:26.990 --> 00:55:29.510
deswegen wird immer als erstes Argument in Methoden

00:55:30.310 --> 00:55:31.510
das ist halt auch das

00:55:31.510 --> 00:55:33.330
was dann Methoden von Funktionen unterscheidet

00:55:33.330 --> 00:55:35.650
immer eine Referenz auf

00:55:35.650 --> 00:55:36.730
das

00:55:36.730 --> 00:55:39.390
auf sich selbst sozusagen mit übergeben

00:55:39.390 --> 00:55:41.050
man könnte das auch anders nennen

00:55:41.050 --> 00:55:42.310
man kann auch sagen

00:55:42.310 --> 00:55:45.090
A statt Self, dann ist es A

00:55:45.090 --> 00:55:47.430
aber es ist schon sinnvoll das Self zu nennen, damit man weiß

00:55:47.430 --> 00:55:49.130
dass es halt eine Referenz auf

00:55:49.130 --> 00:55:51.050
sich selbst ist, sozusagen auf das Objekt

00:55:51.050 --> 00:55:52.890
was gerade, was man gerade ist.

00:55:53.210 --> 00:55:54.850
Und dann kann man halt auf Self-Punkt

00:55:54.850 --> 00:55:56.070
irgendwelche Daten zugreifen.

00:55:57.250 --> 00:55:58.830
Da fangen wir jetzt direkt ein paar andere Sachen ein,

00:55:58.870 --> 00:56:00.410
weil wir jetzt gerade so hatten mit Objekt.

00:56:00.590 --> 00:56:02.950
Was ist denn ein Objekt? Es ist eine Klasse und jetzt gibt es

00:56:02.950 --> 00:56:04.950
irgendwie drei Dekoratoren, also wir müssen noch gleich

00:56:04.950 --> 00:56:06.390
darüber sprechen, was ein Dekorator ist,

00:56:06.730 --> 00:56:08.890
aber es gibt drei Dekoratoren, die Python

00:56:08.890 --> 00:56:10.950
verwendet, die da immer so drüber

00:56:10.950 --> 00:56:13.190
stehen. Static Method, Class Method

00:56:13.190 --> 00:56:13.790
und

00:56:13.790 --> 00:56:16.850
Property. Über Property hattest du eben auch schon.

00:56:17.510 --> 00:56:18.870
Was ist denn jetzt da irgendwie

00:56:18.870 --> 00:56:19.750
so der kleine

00:56:19.750 --> 00:56:21.510
Hagen, also wann

00:56:21.510 --> 00:56:23.810
dachte man jetzt zum Beispiel, das ist eine statische Methode

00:56:23.810 --> 00:56:25.310
und wann dachte man, das ist eine Klassenmethode?

00:56:25.450 --> 00:56:27.550
Was heißt das denn in dem Kontext zu Self und

00:56:27.550 --> 00:56:28.350
Objekt und

00:56:28.350 --> 00:56:31.030
Ja, also ich würde eigentlich

00:56:31.030 --> 00:56:32.970
am liebsten mit der

00:56:32.970 --> 00:56:34.850
Klassenmethode anfangen, also

00:56:34.850 --> 00:56:36.370
Class Method

00:56:36.370 --> 00:56:39.250
ist halt eine

00:56:39.250 --> 00:56:41.630
eine

00:56:41.630 --> 00:56:43.310
Methode, die eben nicht eine konkrete

00:56:43.310 --> 00:56:45.390
Instanz, das heißt da fehlt auch

00:56:45.390 --> 00:56:47.390
Self bei der, genau, da könnte man

00:56:47.390 --> 00:56:49.430
jetzt auch Self übergeben, das wäre dann sehr verwirrend

00:56:50.090 --> 00:56:51.270
sondern was man da üblicherweise

00:56:51.270 --> 00:56:53.650
übergibt, ist ein CLS

00:56:53.650 --> 00:56:55.310
oder so und bekommt man die Klasse übergeben.

00:56:55.630 --> 00:56:56.710
Die Klasse ist auch wieder ein Objekt.

00:56:57.850 --> 00:56:59.430
Das ist auch irgendwie, man kann das dann noch ein Stückchen

00:56:59.430 --> 00:57:01.110
weitertreiben, auch dann mit dem Meta-Klassenanschluss.

00:57:02.050 --> 00:57:03.390
Also die kleinste, das kleinste Objekt, also

00:57:03.390 --> 00:57:05.390
jede Klasse ist irgendwie ein Objekt und das Objekt

00:57:05.390 --> 00:57:07.390
Objekt und Objekt selber ist ein Objekt vom Typ-Typ.

00:57:08.630 --> 00:57:09.390
Ja, okay.

00:57:10.310 --> 00:57:11.010
Ja, okay.

00:57:12.090 --> 00:57:12.930
Ja, also

00:57:12.930 --> 00:57:15.830
jedenfalls

00:57:15.830 --> 00:57:17.730
in der Klassenmethode

00:57:17.730 --> 00:57:19.130
übergibt man halt CLS und nicht

00:57:19.130 --> 00:57:21.310
Self, weil man damit halt weiß,

00:57:21.430 --> 00:57:23.090
dass man jetzt gerade die Klasse in der Hand hat und nicht

00:57:23.090 --> 00:57:25.710
eine Referenz

00:57:25.710 --> 00:57:27.030
auf die Instanz.

00:57:27.830 --> 00:57:29.410
Und es gibt

00:57:29.410 --> 00:57:31.230
halt, das verwendet man vor allen Dingen dafür, dass

00:57:31.230 --> 00:57:33.290
man, es gibt halt bestimmte Methoden,

00:57:33.350 --> 00:57:35.190
die brauchen eben nicht, die müssen nicht

00:57:35.190 --> 00:57:37.410
auf irgendwelche internen Daten oder so zugreifen,

00:57:37.470 --> 00:57:38.110
weil die hat man ja nicht.

00:57:39.250 --> 00:57:41.090
Sondern die machen halt,

00:57:41.610 --> 00:57:43.230
die gehören zwar vielleicht irgendwie in die

00:57:43.230 --> 00:57:45.350
Klasse rein, weil die Funktionalität,

00:57:45.350 --> 00:57:47.270
die sie bieten, halt sehr viel zu tun hat mit der

00:57:47.270 --> 00:57:48.610
Klasse, aber die

00:57:48.610 --> 00:57:51.010
verhalten sich in gewisser Weise natürlich dann so

00:57:51.010 --> 00:57:52.770
wie eine normale Funktion.

00:57:54.130 --> 00:57:55.090
Und vielleicht können sie auch

00:57:55.090 --> 00:57:56.490
auf Daten, die halt

00:57:56.490 --> 00:57:58.930
für alle Instanzen dieser Klasse

00:57:58.930 --> 00:58:01.030
gleich sind, zugreifen eben über die Klasse, aber

00:58:01.030 --> 00:58:03.010
die brauchen

00:58:03.010 --> 00:58:03.730
jetzt nicht

00:58:03.730 --> 00:58:07.230
irgendwie eine konkrete

00:58:07.230 --> 00:58:09.070
Instanz, auf der sie irgendwas machen. Also Beispiel

00:58:09.070 --> 00:58:09.490
für

00:58:09.490 --> 00:58:12.890
sowas sind, was ist denn ein gutes

00:58:12.890 --> 00:58:13.610
Beispiel für

00:58:13.610 --> 00:58:21.370
aus dem Spiel, also

00:58:21.370 --> 00:58:24.050
zwei Beispiele, die ich ganz gut zu visualisieren

00:58:24.050 --> 00:58:25.690
finde, entweder hat man so ein Spiel mit so

00:58:25.690 --> 00:58:27.610
Charakteren oder man hat so ein

00:58:27.610 --> 00:58:29.750
Universum mit Planeten und Dingen, die umeinander

00:58:29.750 --> 00:58:31.710
kreisen oder sowas. Zwei verschiedene

00:58:31.710 --> 00:58:33.470
Sonnensysteme als zwei Klassen.

00:58:34.090 --> 00:58:34.930
Okay, lass mir das.

00:58:35.410 --> 00:58:37.590
Ich weiß nicht so genau, ob ich das da irgendwie, also

00:58:37.590 --> 00:58:44.510
mir fällt da jetzt gar nichts

00:58:44.510 --> 00:58:46.290
also es sind oft

00:58:46.290 --> 00:58:48.410
irgendwelche Hilfsfunktionen oder so, die

00:58:48.410 --> 00:58:50.350
was machen, was logisch dann

00:58:50.350 --> 00:58:52.370
in der Klasse gehört, aber wo man nicht mit einer konkreten

00:58:52.370 --> 00:58:53.370
Instanz irgendwas zu tun hat

00:58:53.370 --> 00:58:56.410
mir fällt jetzt tatsächlich kein super tolles Beispiel

00:58:56.410 --> 00:58:57.950
Was ist denn der beste

00:58:57.950 --> 00:59:00.390
Static Method, was wäre das denn jetzt so als

00:59:00.390 --> 00:59:02.610
Ja, Static Method

00:59:02.610 --> 00:59:07.450
Die bekommt halt einfach

00:59:07.450 --> 00:59:08.790
tatsächlich überhaupt nicht mal die Klasse.

00:59:10.310 --> 00:59:11.530
Aber im Prinzip ist das nichts anderes,

00:59:11.690 --> 00:59:13.530
außer dass sie nur nicht mal die Klasse bekommt.

00:59:14.590 --> 00:59:15.390
Das heißt, sie könnte man auch

00:59:15.390 --> 00:59:17.210
draußen hinschreiben. Genau.

00:59:17.570 --> 00:59:19.430
Der einzige Unterschied bei der StaticMethod ist halt, dass sie dann

00:59:19.430 --> 00:59:21.430
im Namespace der Klasse

00:59:21.430 --> 00:59:23.270
oder des Objekts aufrufbar ist oder so.

00:59:29.250 --> 00:59:31.190
Ja, was ist jetzt in dem Vergleich eine StaticMethod?

00:59:31.890 --> 00:59:32.130
Okay.

00:59:33.890 --> 00:59:35.390
Ja, also StaticMethod

00:59:35.390 --> 00:59:37.530
bekommt gar kein

00:59:37.530 --> 00:59:39.570
automatisches Argument

00:59:39.570 --> 00:59:41.350
mit, sozusagen.

00:59:41.510 --> 00:59:42.410
Das wäre dann die reine,

00:59:43.350 --> 00:59:45.550
wäre quasi wie eine Funktion, ja, also es ist

00:59:45.550 --> 00:59:46.670
egal, ob man jetzt Static-Method

00:59:46.670 --> 00:59:48.870
aufruft oder halt

00:59:48.870 --> 00:59:53.550
eine Funktion von draußen, genau.

00:59:54.250 --> 00:59:55.630
Ah, richtig, jetzt fällt

00:59:55.630 --> 00:59:57.530
mir doch wieder ein Beispiel ein zu Class-Method, wo das

00:59:57.530 --> 00:59:59.350
wenn man jetzt

00:59:59.350 --> 01:00:01.290
in Django zum Beispiel Modelle hat,

01:00:02.030 --> 01:00:03.630
dann sind halt

01:00:03.630 --> 01:00:07.550
viele Geschichten,

01:00:07.810 --> 01:00:09.730
die jetzt ein Modell betreffen, die man von außen

01:00:09.730 --> 01:00:11.470
aufrufen kann, ruft man halt auf der Klasse auf

01:00:11.470 --> 01:00:13.670
und nicht auf einer Instanz, weil eine konkrete

01:00:13.670 --> 01:00:14.710
Instanz ist ja zum Beispiel,

01:00:15.530 --> 01:00:16.970
man hat ja die Daten für,

01:00:18.070 --> 01:00:19.290
die Geschichten stehen halt

01:00:19.290 --> 01:00:20.710
in der Datenbank

01:00:20.710 --> 01:00:23.690
und jetzt eine konkrete Instanz

01:00:23.690 --> 01:00:25.450
eines, also Django-Modelle

01:00:25.450 --> 01:00:26.350
sind Klassen

01:00:26.350 --> 01:00:29.030
und sie modellieren sozusagen

01:00:29.030 --> 01:00:31.130
den Zustand, der irgendwie in der Datenbank steht

01:00:31.130 --> 01:00:32.990
und eine Instanz

01:00:32.990 --> 01:00:34.950
üblicherweise ist halt

01:00:34.950 --> 01:00:36.290
eine Zeile, also wenn ich jetzt zum Beispiel

01:00:36.290 --> 01:00:39.110
ein Beispiel User nehme, ja, also ein User-Objekt

01:00:39.110 --> 01:00:40.690
in Django ist halt

01:00:40.690 --> 01:00:42.970
eine Zeile aus der Tabelle

01:00:42.970 --> 01:00:44.970
Users irgendwie und

01:00:44.970 --> 01:00:46.870
hat halt all die Attribute,

01:00:47.030 --> 01:00:48.730
die jetzt irgendwie die Zeile hat, also

01:00:48.730 --> 01:00:50.370
Spalten hat sozusagen in dieser Tabelle.

01:00:50.990 --> 01:00:52.670
Ja, aber ich

01:00:52.670 --> 01:00:54.670
möchte jetzt möglicherweise Dinge machen

01:00:54.670 --> 01:00:55.930
auf der kompletten Tabelle.

01:00:56.590 --> 01:00:58.810
Auf allen Nutzern. Ja, genau, auf allen

01:00:58.810 --> 01:01:00.750
Nutzern oder ich möchte einen neuen Nutzer erzeugen.

01:01:01.550 --> 01:01:02.690
Ja, das kann ich ja jetzt nicht innerhalb

01:01:02.690 --> 01:01:04.630
von einem Nutzer machen, sondern das ist halt

01:01:04.630 --> 01:01:06.230
irgendwie, ja, und dafür

01:01:06.230 --> 01:01:07.770
sage ich dann

01:01:07.770 --> 01:01:10.970
irgendwas, Users.Objects.Create

01:01:10.970 --> 01:01:12.690
und das ist dann halt eine Class-Method,

01:01:13.290 --> 01:01:14.750
die zwar sozusagen

01:01:14.750 --> 01:01:16.850
ja, Informationen über die Klasse braucht

01:01:16.850 --> 01:01:18.530
und wissen muss, was man dann so tut.

01:01:18.710 --> 01:01:20.710
Also Users.Create. Streng genommen ist es

01:01:20.710 --> 01:01:22.750
naja, Objects.Create ist halt

01:01:22.750 --> 01:01:24.730
der Model-Manager, auf den man das aufruft,

01:01:24.810 --> 01:01:26.810
aber das ist halt dann ein Ding,

01:01:26.950 --> 01:01:28.850
aber dieses Objects ist halt... Ja, den Manager lassen wir jetzt mal kurz

01:01:28.850 --> 01:01:30.590
weg, da müssen wir uns schon ein bisschen zu sagen gehen. Ja, es ist nochmal

01:01:30.590 --> 01:01:32.270
komplizierter, aber dieses Objects ist auf jeden Fall

01:01:32.270 --> 01:01:34.170
Dingen, was an der Klasse hängt

01:01:34.170 --> 01:01:34.970
von

01:01:34.970 --> 01:01:42.550
ja, was halt sozusagen

01:01:42.550 --> 01:01:44.530
also man kann sich das so vorstellen, es betrifft halt

01:01:44.530 --> 01:01:46.550
die gesamte Tabelle, man erzeugt jetzt auf dieser Tabelle

01:01:46.550 --> 01:01:48.630
eine neue Zeile und das kann nicht eine Methode

01:01:48.630 --> 01:01:50.250
sein, die man auf einer Instanz aufruft, sondern

01:01:50.250 --> 01:01:52.570
die halt Instanz und die eine Zeile repräsentiert, weil innerhalb

01:01:52.570 --> 01:01:54.070
von der einen Zeile sich selber irgendwie

01:01:54.070 --> 01:01:56.470
ranzeigen würde, gar nicht so richtig funktioniert. Ja, könnte man auch machen,

01:01:56.550 --> 01:01:58.450
wäre irgendwie komisch. Und warum

01:01:58.450 --> 01:02:00.290
nimmt man jetzt aber dafür jetzt nicht einfach eine Static-Method?

01:02:01.130 --> 01:02:05.670
Ja, könnte man auch, aber, nee, kann man nicht,

01:02:05.810 --> 01:02:08.810
weil dann würde man halt zum Beispiel nicht mehr wissen,

01:02:08.950 --> 01:02:10.150
was sind denn jetzt die ganzen Felder.

01:02:10.170 --> 01:02:11.130
Wie der Kontext von der Tabelle wahrscheinlich.

01:02:11.230 --> 01:02:13.070
Genau, man möchte ja auch wissen, welche Attribute gibt es,

01:02:13.130 --> 01:02:16.390
was muss ich eigentlich da, und so, das, ja, das muss man ja auch,

01:02:16.450 --> 01:02:18.270
welche Tabelle ist denn das überhaupt, wo steht die in der Datenbank,

01:02:18.830 --> 01:02:20.110
und das hängt halt an der, das sind Informationen,

01:02:20.270 --> 01:02:23.710
die an der Klasse dranhängen, und, ja.

01:02:23.710 --> 01:02:25.410
Das heißt, die Static Method würde mir sowas sagen,

01:02:25.530 --> 01:02:28.610
wie ist da draußen denn was anderes noch verfügbar,

01:02:28.690 --> 01:02:29.570
das könnte ich dann vielleicht gucken.

01:02:29.670 --> 01:02:31.250
Static Method könnte sowas sein wie

01:02:31.250 --> 01:02:32.230
hash mir mal das Passwort.

01:02:32.990 --> 01:02:34.890
Also hier hast du einen String, mach mir mal einen Hash davon,

01:02:34.970 --> 01:02:36.450
den ich dann irgendwie in die Datenbank schreibe.

01:02:37.250 --> 01:02:38.550
Das braucht gar keinen Kontext.

01:02:38.670 --> 01:02:40.970
Das nimmt irgendwie einen String und gibt einen anderen String raus.

01:02:41.070 --> 01:02:43.010
Das braucht aber sonst überhaupt nichts zu wissen.

01:02:43.870 --> 01:02:45.210
Und das könnte dann ein Static Method

01:02:45.210 --> 01:02:47.170
sein zum Beispiel. Aber es gehört halt logisch

01:02:47.170 --> 01:02:49.270
vielleicht schon in die User-Klasse, weil es halt

01:02:49.270 --> 01:02:50.910
irgendwie um Passwörter geht, die

01:02:50.910 --> 01:02:52.890
ein User eingibt und die dann halt irgendwie

01:02:52.890 --> 01:02:53.510
gehashed werden sollen.

01:02:54.030 --> 01:02:55.570
Jetzt haben wir noch Property.

01:02:56.610 --> 01:02:58.130
Property-Dekorator, ja, der ist

01:02:58.130 --> 01:03:01.170
da geht es eigentlich nur darum,

01:03:01.330 --> 01:03:02.390
dass man

01:03:02.390 --> 01:03:04.970
ja, so ein bisschen Convenience, dass man

01:03:04.970 --> 01:03:06.890
nicht eine Methode aufruft, sondern

01:03:06.890 --> 01:03:08.530
also man schreibt halt

01:03:08.530 --> 01:03:10.630
also der häufigste Fall ist, man hat

01:03:10.630 --> 01:03:12.930
eine Methode, die nennt man so wie

01:03:12.930 --> 01:03:14.990
ein Attribut und schreibt dann addProperty drüber

01:03:14.990 --> 01:03:16.870
und dann

01:03:16.870 --> 01:03:18.830
wird halt diese Methode aufgerufen,

01:03:18.990 --> 01:03:20.330
wenn man irgendwo sagt Instanz.

01:03:21.390 --> 01:03:22.870
Also braucht man eigentlich nicht, man könnte auch

01:03:22.870 --> 01:03:23.750
eine Methode schreiben.

01:03:24.630 --> 01:03:26.890
Ja, aber dann müssen wir halt dann an der Stelle, wo man es

01:03:26.890 --> 01:03:28.690
verwenden will, Klammer auf Klammer

01:03:28.690 --> 01:03:30.770
zusagen, was halt so ein bisschen sinnlos ist,

01:03:30.790 --> 01:03:32.110
wenn man zum Beispiel gar nichts übergeben möchte

01:03:32.110 --> 01:03:34.350
an Argumenten und

01:03:34.350 --> 01:03:36.730
vielleicht auch etwas ist, was halt

01:03:36.730 --> 01:03:38.490
so aussehen soll, als wäre es ein Attribut,

01:03:38.610 --> 01:03:40.410
aber wo man Sachen noch ausrechnen will

01:03:40.410 --> 01:03:42.750
und dann kann man halt den Property-Dekorator

01:03:42.750 --> 01:03:44.150
benutzen, um halt...

01:03:44.150 --> 01:03:46.330
Oh, das ist quasi ein getarntes Methodending.

01:03:46.430 --> 01:03:47.890
Ja, ist so manchmal ein bisschen,

01:03:48.430 --> 01:03:49.310
also das ist auch so,

01:03:50.970 --> 01:03:52.250
diese Dekorator-Geschichte

01:03:52.250 --> 01:03:53.410
ist so manchmal ein bisschen,

01:03:54.710 --> 01:03:55.630
also

01:03:55.630 --> 01:03:58.050
auf Python steht ja sowas, explizit ist besser

01:03:58.050 --> 01:03:59.850
als implizit. Und das ist halt schon ganz schön

01:03:59.850 --> 01:04:02.430
implizit, dass wenn man jetzt irgendwo

01:04:02.430 --> 01:04:04.050
eben

01:04:04.050 --> 01:04:05.450
Instanz

01:04:05.450 --> 01:04:08.090
x.huber sagt, halt dann

01:04:08.090 --> 01:04:10.090
irgendwie Code ausgeführt wird, der irgendwas ausrechnet

01:04:10.090 --> 01:04:11.610
und dann unter Umständen auch sehr langsam sein kann.

01:04:12.050 --> 01:04:13.930
Das ist halt nicht unbedingt, also in dem Moment, wo man

01:04:13.930 --> 01:04:14.950
das halt lokal liest,

01:04:16.130 --> 01:04:17.950
weiß man nicht, was passiert. Was immer so

01:04:17.950 --> 01:04:19.090
ein bisschen schlecht ist. Aber

01:04:19.090 --> 01:04:21.670
ja, es ist eigentlich

01:04:21.670 --> 01:04:23.810
normalerweise, wenn man dann komplizierte Sachen

01:04:23.810 --> 01:04:25.590
macht, dann sollte man das vielleicht dann auch eher

01:04:25.590 --> 01:04:27.510
als Methode hinschreiben und dann

01:04:27.510 --> 01:04:29.370
wird das dann vielleicht klarer.

01:04:29.730 --> 01:04:31.710
Aber wenn man kurz vielleicht zwei Attribute

01:04:31.710 --> 01:04:33.790
hat, wie das eine ist Kosten, das andere

01:04:33.790 --> 01:04:35.710
ist Umsatz und dann will man den

01:04:35.710 --> 01:04:37.630
Gewinn ausrechnen, dann kann man vielleicht schon eine Funktion

01:04:37.630 --> 01:04:39.070
machen, die dann einfach kurz als

01:04:39.070 --> 01:04:41.650
Property sagt, hier gibt man Umsatz

01:04:41.650 --> 01:04:43.490
gewinnen und dann geht das einfach schnell aus.

01:04:43.510 --> 01:04:44.850
Und ja, also

01:04:44.850 --> 01:04:47.390
das Get

01:04:47.390 --> 01:04:49.310
zu implementieren ist sehr leicht, man schreibt irgendwie

01:04:49.310 --> 01:04:51.450
der Property drüber und dann war's das. Das Set

01:04:51.450 --> 01:04:53.550
geht auch, also man kann das auch so machen, dass dann halt ein Setter

01:04:53.550 --> 01:04:54.930
aufgerufen wird, wenn man sagt,

01:04:55.330 --> 01:04:57.490
Instance x.fuba gleich irgendwie.

01:04:58.330 --> 01:04:59.290
Das ist ein bisschen komplizierter,

01:04:59.930 --> 01:05:01.790
aber, tja, geht auch so ähnlich.

01:05:03.610 --> 01:05:03.770
Ja,

01:05:04.250 --> 01:05:05.330
also man kann, ich weiß nicht genau,

01:05:05.330 --> 01:05:07.250
man kann mit dem Property-Dekorator irgendwie sagen,

01:05:07.370 --> 01:05:09.190
das ist hier der Getter, das ist hier der Setter oder was.

01:05:09.270 --> 01:05:11.210
Ach, ich weiß nicht genau. Man kann dann nachgucken, wenn man es braucht.

01:05:11.250 --> 01:05:12.930
Braucht man selten. Also ich

01:05:12.930 --> 01:05:15.130
habe es ein paar Mal benutzt, aber nicht oft.

01:05:16.350 --> 01:05:17.310
Aber überhaupt das

01:05:17.310 --> 01:05:18.570
Konzept von Dekoratoren.

01:05:19.050 --> 01:05:21.190
Getter-Setter bedeutet halt, dass man die Attribute irgendwie

01:05:21.190 --> 01:05:22.690
von außen dann beeinflussen und setzen.

01:05:22.930 --> 01:05:23.950
von der Instanz setzt,

01:05:24.610 --> 01:05:26.130
bekommt oder setzt,

01:05:26.650 --> 01:05:28.890
genau, und zwar nicht direkt manipuliert, sondern

01:05:28.890 --> 01:05:30.990
halt Methoden

01:05:30.990 --> 01:05:33.010
dafür aufruft, die dann noch irgendwas vorher und hinterher tun.

01:05:33.030 --> 01:05:35.010
Jetzt haben wir schon ungefähr 50 Mal Dekorator gesagt und du wolltest

01:05:35.010 --> 01:05:36.930
da nicht noch irgendwas anderes vorher sagen.

01:05:36.930 --> 01:05:38.990
Dann muss man vielleicht nochmal erklären, was ein Dekorator eigentlich ist.

01:05:39.310 --> 01:05:40.210
Eigentlich ist es eine sehr,

01:05:40.910 --> 01:05:42.530
eigentlich nicht so,

01:05:43.850 --> 01:05:45.030
es kann

01:05:45.030 --> 01:05:46.510
leicht kompliziert werden.

01:05:48.690 --> 01:05:49.130
Ja, es ist

01:05:49.130 --> 01:05:51.170
auf der einen Seite ein bisschen Spezial-Syntax,

01:05:52.390 --> 01:05:57.790
Diese Geschichte mit dem Ad-Symbol, dass man halt über Klassen und über Methoden, Funktionen schreiben kann.

01:05:58.750 --> 01:06:02.230
Auf der anderen Seite ist es, man könnte es auch anders hinschreiben.

01:06:02.870 --> 01:06:06.390
Da bräuchte man diese Spezialsyntax nicht, also die einem das so ein bisschen vereinfacht.

01:06:06.390 --> 01:06:16.290
Man könnte halt auch hinschreiben, irgendwie x gleich, wrap mir mal eine andere Funktion, wrap, Klammer auf, irgendwie eine andere Funktion, Klammer zu.

01:06:17.110 --> 01:06:19.650
Und dann wäre das die dekorierte, wäre x die dekorierte Funktion.

01:06:20.810 --> 01:06:23.130
Und man macht sich eine Tapete auf die Wand und unter der

01:06:23.130 --> 01:06:24.770
sieht man dann halt hier Sachen anders.

01:06:25.750 --> 01:06:27.010
Ah, die Form bleibt erhalten, aber die ist dann

01:06:27.010 --> 01:06:27.950
vielleicht rot oder blau.

01:06:28.630 --> 01:06:31.070
Ja, also die Idee ist sozusagen, dass man

01:06:31.070 --> 01:06:34.770
etwas

01:06:34.770 --> 01:06:37.110
macht, also man halt Code hat, der

01:06:37.110 --> 01:06:39.350
ja, man packt,

01:06:39.530 --> 01:06:40.670
deswegen ist Dekorator eigentlich auch

01:06:40.670 --> 01:06:42.530
und das zeichnet ziemlich genau, was es tut.

01:06:44.210 --> 01:06:44.490
Man hat halt...

01:06:44.490 --> 01:06:46.110
Input und Output, der rauskommt oder

01:06:46.110 --> 01:06:47.550
reingeht, wird...

01:06:47.550 --> 01:06:50.210
Geht nochmal durch anderen Code durch und dann

01:06:50.210 --> 01:06:52.770
sozusagen, man kann halt

01:06:52.770 --> 01:06:54.750
bevor irgendwas, bevor die Funktion aufgerufen

01:06:54.750 --> 01:06:56.590
wird, irgendwie Dinge damit tun und

01:06:56.590 --> 01:06:58.830
hinterher Dinge mit dem

01:06:58.830 --> 01:07:00.830
Das wird aber ganz schön langsam, wenn das durch einen Dekorator

01:07:00.830 --> 01:07:02.690
hat, der einen Dekorator hat, der einen Dekorator hat, dann

01:07:02.690 --> 01:07:04.830
Ja, aber normale

01:07:04.830 --> 01:07:06.790
Funktionsaufrufe macht man

01:07:06.790 --> 01:07:08.490
ja auch, ist auch okay, also

01:07:08.490 --> 01:07:10.830
und das ist ja auch nichts anderes im Grunde. Das heißt, wenn man

01:07:10.830 --> 01:07:12.710
einen Dekorator selber schreibt, dann baut man quasi einen eigenen

01:07:12.710 --> 01:07:14.730
Rapper und sagt halt, was passiert, bevor der da reingeht und

01:07:14.730 --> 01:07:15.550
wann der wieder rauskommt.

01:07:16.670 --> 01:07:17.650
Ja, man sollte auch

01:07:17.650 --> 01:07:19.850
tatsächlich

01:07:19.850 --> 01:07:23.290
nicht wirklich, wenn man Dekoratoren

01:07:23.290 --> 01:07:25.110
schreibt, nicht das selber machen,

01:07:25.450 --> 01:07:26.950
sondern man sollte für den Functools

01:07:26.950 --> 01:07:28.330
Wraps oder so nehmen.

01:07:29.310 --> 01:07:31.190
Und weil es gibt

01:07:31.190 --> 01:07:32.930
noch so ein paar Hakeligkeiten mit den

01:07:32.930 --> 01:07:35.110
Funktionsnamen zum Beispiel, die sonst verschwinden,

01:07:35.290 --> 01:07:37.270
wenn man, die sieht man in Tracebacks nicht mehr

01:07:37.270 --> 01:07:39.270
und da muss man so ein bisschen, und dann gibt's

01:07:39.270 --> 01:07:41.190
halt eben in den Functools

01:07:41.190 --> 01:07:42.410
gibt's da glaube ich

01:07:42.410 --> 01:07:43.490
irgendwie

01:07:43.490 --> 01:07:47.170
Funktionen, die, wenn man die benutzt, um

01:07:47.170 --> 01:07:49.110
einen Dekorator zu bauen, dann kümmern die sich um diesen

01:07:49.110 --> 01:07:51.030
Kram, sodass halt dann man in Traceworks weiterhin

01:07:51.030 --> 01:07:52.570
die Namen sieht und so. Also das ist ein bisschen...

01:07:52.570 --> 01:07:54.970
Was hat denn das jetzt mit so einem Kontext zu tun? Kontextmanager oder so?

01:07:55.150 --> 01:07:56.710
Oh nee, das hat aber nichts zu tun.

01:07:56.850 --> 01:07:57.550
Das ist eine andere Geschichte.

01:07:58.530 --> 01:08:00.870
Das hört er sich so ein bisschen an, als macht man irgendwie so einen Kontext auf und

01:08:00.870 --> 01:08:02.910
rappt irgendwas und baut das dann am Ende

01:08:02.910 --> 01:08:03.450
wieder auseinander.

01:08:06.330 --> 01:08:06.610
Also

01:08:06.610 --> 01:08:07.750
ja,

01:08:08.890 --> 01:08:10.550
also was eventuell irgendwie

01:08:10.550 --> 01:08:13.310
eine Gemeinsamkeit

01:08:13.310 --> 01:08:15.030
ist, dass beides irgendwie unten drunter vielleicht

01:08:15.030 --> 01:08:17.210
Closure ist verwendet, weil es, wie das

01:08:17.210 --> 01:08:18.230
umgesetzt ist, aber

01:08:18.230 --> 01:08:20.550
das ist sozusagen

01:08:20.550 --> 01:08:23.290
eine interne Funktion, die halt

01:08:23.290 --> 01:08:25.110
zurückgegeben wird

01:08:25.110 --> 01:08:27.370
und

01:08:27.370 --> 01:08:29.070
die halt, das ist ja auch so der Trick, wie man das hinkriegt,

01:08:29.170 --> 01:08:30.510
dass der Scope,

01:08:30.770 --> 01:08:33.270
dass man halt auf die Sachen zugreifen kann,

01:08:33.270 --> 01:08:34.770
die im Scope der Funktion sind,

01:08:35.290 --> 01:08:36.250
dass man halt sozusagen,

01:08:38.210 --> 01:08:39.450
naja, das ist zu kompliziert,

01:08:39.550 --> 01:08:41.190
das kann man alles nicht so, das ist auch nicht entfängermäßig,

01:08:41.230 --> 01:08:43.330
das kann man nicht gut erklären, da muss man sich einfach mal,

01:08:43.710 --> 01:08:44.810
also ich würde sagen, also ein Tipp ist,

01:08:45.030 --> 01:08:51.550
und wenn man Dekoratoren schreiben will, aus den Functools die Wraps-Funktion zu nehmen

01:08:51.550 --> 01:08:55.550
und einfach mal so ein bisschen damit rumzuspielen.

01:08:55.630 --> 01:08:58.970
Man braucht ein bisschen, bis man das so raus hat.

01:09:02.530 --> 01:09:03.910
Aber dafür sind Dekoratoren da.

01:09:04.470 --> 01:09:06.790
Man kann damit ganz nette Sachen machen, wie zum Beispiel,

01:09:07.750 --> 01:09:10.390
also wenn man einfach nur wissen will, wofür braucht man solche Sachen eigentlich.

01:09:10.870 --> 01:09:19.150
Wenn man, ja zum Beispiel eben wieder Datenbankgeschichte, kann man sagen, okay, gibt es einen Transaktions-Dekorator, da schreibt man einfach drüber.

01:09:19.690 --> 01:09:20.950
A Transaction Atomic.

01:09:21.190 --> 01:09:33.630
Genau. Das hier ist jetzt alles in einer Transaktion und alle Schritte gehen zusammen gut oder gar nicht. Und wenn halt zwischendurch irgendwas nicht funktioniert hat, dann rollt das automatisch die Datenbank in den ursprünglichen Zustand zurück, als wäre nichts passiert.

01:09:33.710 --> 01:09:37.510
Das ist ein tolles Beispiel, weil da gibt es nämlich auch den Kontextmanager, man kann auch sagen, with a Transaction Atomic.

01:09:37.510 --> 01:09:56.530
Ja, ja, ja, genau. Klar, kann man auch machen. Das ist eine Geschichte. Ansonsten, man kann auch Dekoratoren dafür benutzen, um sich jetzt eine bestimmte Datenbankverbindung immer reinzuholen in eine Funktion.

01:09:56.530 --> 01:09:58.070
Ja, da werden wir jetzt gerade über Tango reden.

01:09:58.150 --> 01:10:00.550
Da wird das ja auch benutzt, zum Beispiel, um Funktionen zu dekorieren.

01:10:00.630 --> 01:10:02.890
Login required, dass man halt irgendwie eingeloggter Benutzer sein muss.

01:10:03.450 --> 01:10:05.670
Das heißt, die Frage ist halt, was er dann macht.

01:10:06.050 --> 01:10:07.310
Das kann man auch als Mixin benutzen.

01:10:07.430 --> 01:10:10.030
Das heißt, auch das wäre eine ähnliche Methode.

01:10:10.110 --> 01:10:13.850
Ein Mixin ist eine Subklasse, eine Klasse, die man benutzt,

01:10:13.910 --> 01:10:15.470
um bestimmte Attribute zusätzlich dazu zu packen.

01:10:15.470 --> 01:10:21.270
Mixin sind so ein bisschen eben, wie man Code wiederverwenden kann,

01:10:21.990 --> 01:10:23.770
in Klassen ohne erben zu müssen.

01:10:23.770 --> 01:10:27.590
Weil Erben macht natürlich das ganz klassische Weg und das kann man natürlich auch tun.

01:10:27.650 --> 01:10:33.430
Ja, also in gewisser Weise ist es ja eine Form von Vererben, aber eine generalisierte Form, die irgendwie jetzt nichts genau mit der ursprünglichen Klasse zu tun hat.

01:10:33.790 --> 01:10:43.910
Ja, genau. Also du kannst halt, ist es nicht so, dass du, ja, also zwei unterschiedliche Klassen, die nichts miteinander zu tun haben, ganz unterschiedliche Stellen in der Klassengereiche sind, können halt das gleiche Mix-In verwenden.

01:10:44.370 --> 01:10:47.670
Cool, das ist so ein bisschen wie Genetik. Du kannst dem Frosch Flügel geben oder so.

01:10:48.650 --> 01:10:53.850
Ja, warum auch nicht?

01:10:55.990 --> 01:10:57.430
Ja, wenn man die Flügel haben will,

01:10:57.490 --> 01:10:59.430
man hat irgendwie eine Klasse, die Flügel bereitstellt,

01:10:59.490 --> 01:11:01.030
dann kann man diese Flügel jeder Klasse geben.

01:11:01.290 --> 01:11:04.330
Ja, macht natürlich auch nicht immer Sinn.

01:11:04.790 --> 01:11:08.930
Aber also Vererbung ist auch so ein problematisches Gefühl.

01:11:09.030 --> 01:11:09.870
Das ist immer das, was einem,

01:11:10.150 --> 01:11:12.530
wenn man sich mit objektorientierter Programmierung beschäftigt,

01:11:12.530 --> 01:11:14.570
irgendwie so gesagt wird, wie man das tun soll oder so am Anfang.

01:11:14.690 --> 01:11:16.750
Keine Ahnung, jedenfalls bei mir ist es mittlerweile auch besser geworden,

01:11:17.470 --> 01:11:19.630
dass man halt Sachen von Dingen dann erbt,

01:11:19.850 --> 01:11:22.090
dass man halt, keine Ahnung,

01:11:24.170 --> 01:11:25.790
ja, weiß ich nicht, da wird immer mit

01:11:25.790 --> 01:11:28.050
solchen Beispielen gearbeitet,

01:11:28.050 --> 01:11:28.410
was

01:11:28.410 --> 01:11:33.030
dass man

01:11:33.030 --> 01:11:35.990
irgendwie, keine Ahnung, meistens irgendwelche geometrischen Formen

01:11:35.990 --> 01:11:38.010
oder sowas, irgendwie, wenn man

01:11:38.010 --> 01:11:40.050
jetzt ein rechtwinkliges Dreieck hat, dann ist das

01:11:40.050 --> 01:11:42.030
auf jeden Fall schon mal ein Dreieck und ein Dreieck

01:11:42.030 --> 01:11:43.270
ist irgendwas, was halt irgendwie...

01:11:43.270 --> 01:11:45.690
Ja, ich finde das gar nicht so schlecht, das nämlich dem Gradius auch vorzustellen.

01:11:45.870 --> 01:11:48.750
Also die Gourmet-Reformen sind zwar ganz okay,

01:11:48.930 --> 01:11:52.390
aber vielleicht auch mit dieser Universumsgeschichte.

01:11:52.650 --> 01:11:54.890
Du hast irgendwo ein großes schwarzes Loch,

01:11:54.970 --> 01:11:55.930
so den Urknall oder sowas.

01:11:56.210 --> 01:11:58.730
Und ein Objekt orbitet da irgendwie herum.

01:11:58.890 --> 01:12:00.630
Das ist jetzt vielleicht schon mal so eine Galaxie,

01:12:00.630 --> 01:12:02.610
und dann, das ist also die

01:12:02.610 --> 01:12:04.670
Subklasse, wäre es halt Universum, das wäre

01:12:04.670 --> 01:12:06.530
die Basisklasse, von der alles irgendwie erbt,

01:12:06.590 --> 01:12:08.770
alles so ein Ding. Das ist ein bisschen groß.

01:12:09.090 --> 01:12:10.690
Ja, dann hast du halt eine Galaxie, das ist ja schon

01:12:10.690 --> 01:12:12.710
das erste kleine Ding, dann, oh, okay, in der Galaxie

01:12:12.710 --> 01:12:14.590
gibt es jetzt ein Sonnensystem. Ein Sonnensystem ist auf jeden Fall

01:12:14.590 --> 01:12:16.490
Teil einer Galaxie, da gelten halt die gleichen Gesetze,

01:12:16.590 --> 01:12:18.550
physikalischen Gesetze. Und dann hast du ein Sonnensystem, hast du

01:12:18.550 --> 01:12:20.030
einen Planeten, das ist jetzt vielleicht schon unsere

01:12:20.030 --> 01:12:22.510
speziellere Klasse. Und dann weißt du halt, genau,

01:12:22.590 --> 01:12:24.230
das gibt verschiedene Sonnensysteme, die haben vielleicht

01:12:24.230 --> 01:12:26.550
gleiche Grundlagen und Planeten,

01:12:26.650 --> 01:12:28.290
können jetzt aber verschiedene Dinge

01:12:28.290 --> 01:12:30.610
besonders machen. Ja, aber ich glaube,

01:12:30.630 --> 01:12:32.250
ich fürchte, also das wird auch,

01:12:32.530 --> 01:12:33.810
also mit solchen Dingen,

01:12:34.230 --> 01:12:35.790
glaube ich, dass Leute versuchen, da irgendwie so

01:12:35.790 --> 01:12:38.770
Alltags-Ontologie irgendwie...

01:12:38.770 --> 01:12:40.030
Ja, aber der Orbit ist ja schon,

01:12:40.210 --> 01:12:42.530
das passt ja schon, weil dieser Planet, der orbitet

01:12:42.530 --> 01:12:44.330
ja, ne, dieser,

01:12:44.770 --> 01:12:46.730
diesem Stern, und der Stern, der orbitet

01:12:46.730 --> 01:12:48.390
ja dem Zentrum dieser Galaxis, so.

01:12:48.990 --> 01:12:50.310
Ja, dann wäre sozusagen die

01:12:50.310 --> 01:12:52.330
allgemeinste Oberklasse wäre sowas wie Himmelskörper

01:12:52.330 --> 01:12:53.830
oder sowas, oder keine Ahnung.

01:12:54.090 --> 01:12:56.610
Nee, nee, nee, ich glaube, das ist gar nicht so,

01:12:56.890 --> 01:12:58.570
also Himmelskörper-Objekt, na, ich weiß nicht.

01:12:59.010 --> 01:13:00.570
Du brauchst ja schon ein Orbit, das ist ja

01:13:00.570 --> 01:13:02.490
Ja, aber ich würde nicht,

01:13:02.690 --> 01:13:03.950
ich würde, also das, ich sehe,

01:13:04.030 --> 01:13:06.790
ich sehe, dass das immer wieder

01:13:06.790 --> 01:13:08.750
passiert und das solche Leute, dass das versucht wird,

01:13:08.790 --> 01:13:10.690
das so zu beschreiben und ich finde, das ist

01:13:10.690 --> 01:13:12.810
nicht hilfreich, weil, ähm.

01:13:12.830 --> 01:13:13.850
Also Mond, Vermieter, Planet.

01:13:16.170 --> 01:13:16.670
Ja, das.

01:13:16.930 --> 01:13:18.390
Du hast ja irgendwie immer so eine Basisklasse, ja,

01:13:18.430 --> 01:13:20.450
und die Basisklasse vom Mond wäre jetzt der Planet, die Basisklasse

01:13:20.450 --> 01:13:22.430
vom Planeten wäre das Sonnensystem, die Basisklasse

01:13:22.430 --> 01:13:24.490
vom Sonnensystem wäre dann das Universum, die Basisklasse

01:13:24.490 --> 01:13:26.310
von dem Universum wäre dann vielleicht irgendwie, ne.

01:13:26.690 --> 01:13:28.590
Ja, nee, genau solche Sachen will man eigentlich nicht machen.

01:13:28.590 --> 01:13:46.650
Also das ist genau das, was ich, also das ist halt, ja, das klingt so ein bisschen danach, als würde das, aber ich würde das nicht versuchen so auf die Alltagswelt so zu applizieren, sondern es geht tatsächlich darum, dass man Sachen programmieren kann und das ist, das ist oft nicht so wie, das ist halt anders.

01:13:46.650 --> 01:14:04.330
Das ist nicht so wie die Welt da draußen, das ist schwer. Oft ist es nicht so, dass man die Welt da draußen modellieren muss und dann das, was man modellieren muss, ist ganz anders als das, was man so draußen normalerweise, man versucht diese Analogien, die gehen immer so ein bisschen ins, ich habe da Schwierigkeiten mit und ich finde, man kann sich das anders besser merken.

01:14:04.330 --> 01:14:21.510
Wenn man jetzt, also ich würde sagen, vererben sollte man einfach eher nicht machen, lieber nicht machen. Also es gibt Fälle, wo das richtig und wichtig ist, aber die sind selten. Und was einem aber erklärt wird, ist, dass das der Normalfall ist, so macht man das halt.

01:14:21.510 --> 01:14:50.390
Dann würde ich sagen, das ist ganz falsch. Nein, so macht man das eigentlich nicht. Also Vererbung, es gibt Fälle, wo das geht, wo das sinnvoll ist, aber das ist nicht so, dass man das immer machen oder normalerweise so machen sollte, sondern das ist halt eher die Ausnahme. Normalerweise sollte man, wenn man zum Beispiel Code in zwei Klassen wiederverwenden will, dann macht man halt Mixen und nicht diese Vererbung, weil das ist halt, auch am Anfang, das geht ganz gut, sobald es komplizierter wird, hat man da große Probleme, weil deine Hierarchie, die muss halt einfach stimmen, die muss halt passen auf dein Problem.

01:14:50.390 --> 01:14:52.330
und das kannst du hinterher nicht mehr gut ändern

01:14:52.330 --> 01:14:54.430
und hinterher gut anpassen, das geht alles nicht

01:14:54.430 --> 01:14:56.470
so richtig schön und am Anfang zu sehen,

01:14:56.930 --> 01:14:58.510
wie das richtig wäre für das Problem, was man

01:14:58.510 --> 01:15:00.010
eigentlich lösen will, ist sehr schwer.

01:15:00.170 --> 01:15:01.510
Ja, weil man das Problem meistens gar nicht genau weiß.

01:15:01.510 --> 01:15:03.070
Genau, man kennt meistens das Problem nicht richtig

01:15:03.070 --> 01:15:05.230
und bei Mixins ist es relativ simpel,

01:15:05.310 --> 01:15:07.270
das ist halt so wie, keine Ahnung, wenn ich nur,

01:15:07.550 --> 01:15:09.250
wenn ich ohne Objektorientierung

01:15:09.250 --> 01:15:11.950
programmiere, dann habe ich halt Funktionen,

01:15:11.950 --> 01:15:13.510
die ich aufrufe und

01:15:13.510 --> 01:15:15.210
wenn ich jetzt merke, ich benutze

01:15:15.210 --> 01:15:17.350
den gleichen Code an drei, vier unterschiedlichen Stellen,

01:15:17.870 --> 01:15:18.910
ja, dann

01:15:18.910 --> 01:15:20.730
mache ich halt eine Funktion

01:15:20.730 --> 01:15:23.090
draus und rufe den an den Stellen, wo ich

01:15:23.090 --> 01:15:25.310
sozusagen das verwenden möchte,

01:15:25.410 --> 01:15:26.470
den Code einfach auf.

01:15:27.070 --> 01:15:28.470
Anstelle, dass ich den Code aber nicht stehen habe.

01:15:29.130 --> 01:15:30.990
Und genauso kann man das mit Klassen im Grunde auch machen

01:15:30.990 --> 01:15:33.230
und Code, den ich in mehreren Klassen benutze,

01:15:33.290 --> 01:15:34.330
den ziehe ich halt in Mixins raus.

01:15:35.290 --> 01:15:36.990
Und dann ist es relativ easy,

01:15:37.130 --> 01:15:37.350
weil

01:15:37.350 --> 01:15:41.050
diese Mixins machen halt

01:15:41.050 --> 01:15:42.850
nichts anderes, außer irgendwie halt

01:15:42.850 --> 01:15:45.070
eine Methode sozusagen hinzuzufügen zu einer Klasse.

01:15:46.370 --> 01:15:47.610
ja,

01:15:50.070 --> 01:15:51.150
während so Vererbungen,

01:15:51.390 --> 01:15:51.730
hm,

01:15:52.590 --> 01:15:54.210
das macht halt mehr.

01:15:55.230 --> 01:15:56.950
Das tut mehr, also es gibt halt dann diese

01:15:56.950 --> 01:15:59.130
Basis, Basis-Klassen, Basis oder so was,

01:15:59.190 --> 01:16:00.990
oder es gibt noch so was wie Message,

01:16:01.090 --> 01:16:03.230
Resolution-Order, MROs, wo man dann gucken kann,

01:16:03.610 --> 01:16:05.150
welche Methoden in welcher Reihenfolge aufrufen

01:16:05.150 --> 01:16:06.810
werden, weil die sich ja gegenseitig überschreiben können

01:16:06.810 --> 01:16:09.150
und das Problem, was man dann hat, irgendwann ist

01:16:09.150 --> 01:16:10.990
das, wenn man da, wie du sagst, einen Fehler macht,

01:16:11.050 --> 01:16:12.270
dann hat man

01:16:12.270 --> 01:16:14.230
Circle-Vererbung oder so was.

01:16:15.030 --> 01:16:45.010
Ja, das passieren halt, genau, wenn man irgendwas falsch macht, dann passieren unerwartete Dinge, die man auch nicht so, die nicht so offensichtlich sind und ja, und es kann auch sehr schnell sehr hässlich werden, also es gibt wenig Fälle, wo das eine super sinnvolle Geschichte ist, das ist immer so, es ist halt so ein bisschen auch wieder wie bei den Dekoratoren, auch wenn man das am Anfang mal verstanden hat, wie das funktioniert, also ich meine, auch wenn man das mit der Vererbung verstanden hat, wie das funktioniert, dann ist das, dann fühlt sich das so toll an, dass man da ganz viele Dekoratoren machen will, ganz viele Vererbungen und am besten das Ganze irgendwie in den

01:16:45.030 --> 01:16:46.730
verschachtelte List-Comprehensions-Fakt oder so.

01:16:46.950 --> 01:16:48.270
Und mit Abtrag Meta-Klassen bitte?

01:16:48.710 --> 01:16:49.710
Ja, Meta-Klassen, oh ja.

01:16:51.950 --> 01:16:52.350
Aber

01:16:52.350 --> 01:16:54.930
ich weiß nicht, vielleicht keine gute Idee.

01:16:55.090 --> 01:16:55.870
Also jedenfalls nicht am Anfang.

01:16:57.210 --> 01:16:58.990
Wenn man dann irgendwann genau

01:16:58.990 --> 01:17:00.850
weiß, welches Problem man lösen möchte und man möchte

01:17:00.850 --> 01:17:03.010
halt ein Framework bauen, das halt, wo man

01:17:03.010 --> 01:17:04.970
dann, also nehmen wir irgendwie sowas wie General REST-Framework,

01:17:05.030 --> 01:17:06.010
finde ich das relativ gelungen.

01:17:07.010 --> 01:17:08.790
Da kann man oft viel

01:17:08.790 --> 01:17:10.930
Funktionalität abbilden, dadurch, dass

01:17:10.930 --> 01:17:12.450
man jetzt sozusagen von irgendeinem

01:17:12.450 --> 01:17:14.830
Viewset oder so erbt und

01:17:14.830 --> 01:17:16.730
dann überschreibt man noch zwei, drei Methoden, passt

01:17:16.730 --> 01:17:18.230
ein bisschen was an und dann macht das ganz viel.

01:17:19.070 --> 01:17:20.650
Sehr schön, aber dafür muss man sehr, sehr genau

01:17:20.650 --> 01:17:22.830
verstanden haben, welches Problem man hat und

01:17:22.830 --> 01:17:24.810
wenn man

01:17:24.810 --> 01:17:26.050
so anfängt, dann

01:17:26.050 --> 01:17:28.230
üblicherweise landet man relativ

01:17:28.230 --> 01:17:30.970
schnell in einem ziemlich üblen Zustand.

01:17:31.050 --> 01:17:32.350
In Teufelsküche, in der Schlangengrube.

01:17:32.890 --> 01:17:33.250
Ja, genau.

01:17:34.650 --> 01:17:36.430
Man kann das ja immer noch machen am Schluss, wenn man dann

01:17:36.430 --> 01:17:38.670
wirklich verstanden hat, was man tut und so, dann kann man ja

01:17:38.670 --> 01:17:40.350
immer noch dann irgendwie Klassengereiche hinbauen und so.

01:17:40.450 --> 01:17:42.450
Aber am Anfang lieber nicht.

01:17:42.450 --> 01:17:44.270
Ich glaube, das ist jetzt der richtige Ort für die nächste Frage.

01:17:44.570 --> 01:17:46.030
Die wäre, was heißt ein Monkey-Patch?

01:17:47.950 --> 01:17:48.810
Ja, das ist,

01:17:49.250 --> 01:17:50.790
da das alles Objekte sind in Python,

01:17:51.110 --> 01:17:52.770
kann man die natürlich, und die alle

01:17:52.770 --> 01:17:54.570
dynamisch

01:17:54.570 --> 01:17:56.790
änderbar sind, kann man ja auch

01:17:56.790 --> 01:17:58.150
sozusagen einfach die Methode

01:17:58.150 --> 01:18:00.890
eines Objektes einfach,

01:18:01.210 --> 01:18:02.110
man kann ja sagen, zum Beispiel, wenn ich

01:18:02.110 --> 01:18:05.050
nicht nur Attribute setze, sondern ich kann

01:18:05.050 --> 01:18:06.850
auch die Methode einfach überschreiben. Ich könnte zum Beispiel

01:18:06.850 --> 01:18:08.930
sagen, wenn ich meinen Barbaren habe, von dem wir eben

01:18:08.930 --> 01:18:10.910
geredet haben, und er hat ein Attribut,

01:18:10.910 --> 01:18:12.710
das heißt Attacke, und da ist immer irgendwas drauf,

01:18:13.510 --> 01:18:14.610
Dann kann ich einfach die überschreiben.

01:18:14.730 --> 01:18:16.730
Dann macht er bei der Attacke irgendwas anderes, zum Beispiel heilte ich oder so.

01:18:16.750 --> 01:18:18.370
Genau, genau. Und ich könnte einfach sagen,

01:18:18.570 --> 01:18:19.430
ja,

01:18:20.630 --> 01:18:22.490
baba.attack gleich

01:18:22.490 --> 01:18:24.790
lambda xyz, was auch immer

01:18:24.790 --> 01:18:26.690
da übergeben wird. Das wäre zum Beispiel

01:18:26.690 --> 01:18:28.950
wahrscheinlich die Möglichkeit, wie man

01:18:28.950 --> 01:18:30.970
Vererbung bei Klassen

01:18:30.970 --> 01:18:32.750
richtig macht, indem man die Basisklasse hat, die wäre

01:18:32.750 --> 01:18:34.910
jetzt wahrscheinlich in so einem

01:18:34.910 --> 01:18:36.870
Rollenspiel sowas wie eine Person

01:18:36.870 --> 01:18:38.930
und dann vererbt man dann auch verschiedene

01:18:38.930 --> 01:18:41.010
Rassen,

01:18:41.110 --> 01:18:42.810
zum Beispiel Echse oder Mensch oder sowas.

01:18:43.170 --> 01:18:45.150
naja, nee, ich wäre da sehr vorsichtig.

01:18:45.170 --> 01:18:47.250
Und dann hat man dann Klassen, die man dazu macht,

01:18:47.370 --> 01:18:48.970
also zum Beispiel Magier oder Barbar

01:18:48.970 --> 01:18:51.190
und dann kann man zum Beispiel Attacke

01:18:51.190 --> 01:18:52.930
oder so was schreiben.

01:18:53.490 --> 01:18:55.010
Ja, aber das ist halt sehr

01:18:55.010 --> 01:18:57.070
verführerisch, dass man halt ein Bild davon hat, wie das

01:18:57.070 --> 01:18:59.070
wie sozusagen die Welt, die man

01:18:59.070 --> 01:19:00.290
im Spiel bauen will,

01:19:00.790 --> 01:19:03.170
aufgebaut ist, aber tatsächlich ist das zu programmieren

01:19:03.170 --> 01:19:05.070
oft was anderes, als nur diese Welt zu

01:19:05.070 --> 01:19:07.130
modellieren und dann, das ist nicht

01:19:07.130 --> 01:19:08.810
das, oder jedenfalls meine Erfahrung ist so, dass

01:19:08.810 --> 01:19:11.030
wenn man das so versucht zu modellieren, wie man

01:19:11.030 --> 01:19:12.950
sich das vorstellt, dann passt es nicht

01:19:12.950 --> 01:19:14.410
so gut auf das, wie man das programmieren will.

01:19:15.430 --> 01:19:16.610
Sondern es ist halt einfach,

01:19:16.930 --> 01:19:18.490
ja, es ist...

01:19:18.490 --> 01:19:20.270
Aber das zu verstehen, das ist vielleicht

01:19:20.270 --> 01:19:22.830
schwierig, also für jemand, der das nicht weiß, warum,

01:19:22.930 --> 01:19:24.830
wieso, warum man das dann einfach nicht macht, obwohl das

01:19:24.830 --> 01:19:26.770
ja so intuitiv endlich so einen Zugang dazu gibt.

01:19:26.770 --> 01:19:29.170
Ja, genau, also ich, das ist

01:19:29.170 --> 01:19:30.790
halt, es gibt da auch immer diesen

01:19:30.790 --> 01:19:32.950
Spruch, es gibt für jedes Problem eine Lösung, die ist

01:19:32.950 --> 01:19:34.950
einfach, leicht

01:19:34.950 --> 01:19:36.970
zu verstehen, elegant und

01:19:36.970 --> 01:19:37.250
falsch.

01:19:39.350 --> 01:19:40.530
Das ist halt auch immer, und ich,

01:19:40.850 --> 01:19:42.810
was mich ärgert so ein bisschen, ist, dass es halt auch immer so

01:19:42.810 --> 01:19:45.170
Programmierlehrbüchern oder so oft so

01:19:45.170 --> 01:19:46.690
oder schlimm ist es,

01:19:47.170 --> 01:19:48.450
wenn Leute Programmieren

01:19:48.450 --> 01:19:51.070
erklären und dann vielleicht gar nicht selber

01:19:51.070 --> 01:19:53.090
so da drin stecken, dann machen die

01:19:53.090 --> 01:19:55.250
das oft so, dann fangen die da an mit irgendwelchen Analogien

01:19:55.250 --> 01:19:57.090
aus dem täglichen Leben zu kommen und dass man

01:19:57.090 --> 01:19:59.190
halt so das abbildet, das ist

01:19:59.190 --> 01:20:01.030
aber, ich weiß nicht,

01:20:01.630 --> 01:20:03.170
da liegt kein Segen drauf.

01:20:03.990 --> 01:20:05.070
Das funktioniert

01:20:05.070 --> 01:20:05.490
so nicht.

01:20:07.090 --> 01:20:07.530
Ja.

01:20:09.110 --> 01:20:11.070
Naja. Also ihr seht schon, wenn

01:20:11.070 --> 01:20:13.070
Wenn ihr über die Schlangengrube drüber wollt, dann ist da manchmal

01:20:13.070 --> 01:20:14.750
so ein bisschen, ja,

01:20:15.430 --> 01:20:17.190
Indiana Jones-Seit hängt von der Decke rüber schwingen.

01:20:17.590 --> 01:20:18.630
Ich würde, so

01:20:18.630 --> 01:20:20.810
Ratschlag wäre halt eher,

01:20:20.930 --> 01:20:23.150
versuchen einfach zu halten, nicht so komplizierte Sachen,

01:20:23.250 --> 01:20:25.170
so ganz komplizierten Sprachwitscher sind vielleicht nicht so viel

01:20:25.170 --> 01:20:26.610
zu verwenden oder

01:20:26.610 --> 01:20:28.550
das ein bisschen hinaus zu zögern.

01:20:29.370 --> 01:20:31.090
Ja, ich verstehe natürlich, dass das immer so ein bisschen

01:20:31.090 --> 01:20:32.390
auch reizvoll ist, aber

01:20:32.390 --> 01:20:35.090
nicht irgendwie so, wenn so Dinge

01:20:35.090 --> 01:20:37.170
so aussehen, als wie die Weltform, die alles löst.

01:20:39.330 --> 01:20:40.550
Sehr skeptisch sein.

01:20:41.070 --> 01:20:44.190
Ja, dann machen wir direkt wieder mit einfachen Dingen weiter.

01:20:45.630 --> 01:20:49.030
Was sind denn Argumente oder Keyword-Argumente?

01:20:49.150 --> 01:20:50.210
Was sind Arcs und Quarks?

01:20:51.110 --> 01:20:52.050
Ah, ja, ja, ja.

01:20:52.050 --> 01:20:54.150
Das ist auch etwas, was immer ein bisschen verwirrend ist.

01:20:55.050 --> 01:20:58.450
Ja, also Funktionen, Methoden haben Argumente.

01:20:58.730 --> 01:21:01.090
Das heißt, Dinge, die man übergeben kann.

01:21:03.770 --> 01:21:08.970
Ganz normale Positionsargumente sind halt sozusagen das Übliche irgendwie.

01:21:08.970 --> 01:21:25.530
Die haben halt eine feste Stelle und werden dadurch dann identifiziert, dass sie halt an der ersten, zweiten, dritten Stelle oder so stehen. Und dann gibt es halt noch Keyword-Argumente, wo man dann explizit dazu sagt, welches Argument man denn jetzt gemeint hat.

01:21:25.990 --> 01:21:53.810
Das schreibt man dann halt sowohl in die Funktionsdefinitionen rein, als auch dann, wenn man es übergibt, wobei man es beim Übergeben nicht unbedingt braucht, also da ist es dann halt so, wenn man das weglässt, dann wird halt das nächste Keyword-Argument genommen, das ist so ein bisschen, da können dann komische Sachen passieren und dann ist es auch so, dass man, wenn man jetzt eine Liste von Argumenten übergibt, dann kann man die natürlich alle einzeln übergeben,

01:21:53.810 --> 01:21:55.930
man kann die aber auch insgesamt übergeben.

01:21:56.210 --> 01:21:57.710
Mit Stähnchen dann bei Argumenten oder

01:21:57.710 --> 01:21:59.510
mit Stähnchen, Stähnchen bei Keyword-Argumenten.

01:21:59.570 --> 01:22:00.990
Also wenn man die Liste hat in der Hand,

01:22:01.530 --> 01:22:03.250
wenn man eine Liste hat oder Tupel, dann kann man einfach

01:22:03.250 --> 01:22:05.810
einen Stern davor schreiben und

01:22:05.810 --> 01:22:07.790
dann wird das automatisch sozusagen als

01:22:07.790 --> 01:22:09.030
ja

01:22:09.030 --> 01:22:11.530
Argumente dann übergeben.

01:22:11.790 --> 01:22:13.270
Als Impact dann, als Argumenten.

01:22:13.390 --> 01:22:14.490
Genau, man sagt dann irgendwie

01:22:14.490 --> 01:22:17.570
Funktion, Klammer auf,

01:22:17.810 --> 01:22:19.550
Stern und dann eben

01:22:19.550 --> 01:22:21.730
Args, Argumente

01:22:21.730 --> 01:22:23.230
oder wie auch immer das, die Items,

01:22:23.430 --> 01:22:25.390
diese Struktur heißt, die man jetzt gerade in der Hand hat,

01:22:25.770 --> 01:22:27.490
Klammer zu und dann kann man in der

01:22:27.490 --> 01:22:29.170
Funktionsdefinition drin stehen haben, so was

01:22:29.170 --> 01:22:31.390
def Funktion, Klammer auf,

01:22:31.550 --> 01:22:33.130
a, b, c und

01:22:33.130 --> 01:22:35.490
ja, muss dann natürlich alles irgendwie stimmen von

01:22:35.490 --> 01:22:37.470
der Anzahl und so, aber das passiert dann

01:22:37.470 --> 01:22:39.350
automatisch. Ich finde bei Keyword-Argumenten relativ

01:22:39.350 --> 01:22:41.510
nützlich, weil da kann man alle viele Sachen, die man irgendwie zugewiesen

01:22:41.510 --> 01:22:43.670
hat, irgendwie in eine Liste packen

01:22:43.670 --> 01:22:45.390
und dann kann man die einfach alles

01:22:45.390 --> 01:22:47.430
mit Sternchen, Sternchen übergeben und hat dann seine Keywords.

01:22:48.030 --> 01:22:49.390
Genau, das eben

01:22:49.390 --> 01:22:51.510
bei normalen Positionsargumenten

01:22:51.510 --> 01:22:53.210
ist es halt, entweder man

01:22:53.210 --> 01:22:55.350
übergibt sie per Position oder Stern,

01:22:55.910 --> 01:22:57.490
kann auch eben in der

01:22:57.490 --> 01:22:59.410
Funktionsdefinition sagen, das können jetzt hier

01:22:59.410 --> 01:23:01.690
beliebig viele sein, dann schreibt man halt nicht a, b, c

01:23:01.690 --> 01:23:03.550
rein, sondern Stern, args,

01:23:04.430 --> 01:23:05.370
Komma, und dann

01:23:05.370 --> 01:23:07.090
kommen dann halt beliebig viele

01:23:07.090 --> 01:23:09.550
Argumente rein, die dann hinterher in der Liste

01:23:09.550 --> 01:23:11.590
args sind, wenn man, vielleicht kennen

01:23:11.590 --> 01:23:13.350
Leute das noch von Perl oder so, gibt das nur so.

01:23:14.490 --> 01:23:15.470
Das geht in Python auch,

01:23:16.350 --> 01:23:17.430
ist da aber ein Spezialfall.

01:23:19.090 --> 01:23:19.790
Oder, genau,

01:23:19.930 --> 01:23:21.510
Und das Ganze geht mit Keyword-Argumenten

01:23:21.510 --> 01:23:23.410
ganz genau so, nur dass es dann halt nicht Stern ist, sondern

01:23:23.410 --> 01:23:25.650
Stern, Stern. Und damit lassen sich

01:23:25.650 --> 01:23:26.470
halt sehr, sehr leicht

01:23:26.470 --> 01:23:28.650
zum Beispiel Dicts in

01:23:28.650 --> 01:23:31.810
Keyword-Argumente verwandeln und Keyword-Argumente

01:23:31.810 --> 01:23:33.610
in Dicts, was

01:23:33.610 --> 01:23:34.830
halt manchmal sehr praktisch ist.

01:23:35.830 --> 01:23:37.490
Und an viel Schreibarbeit auch Sport.

01:23:41.210 --> 01:23:43.210
Cool. Jetzt haben wir noch zwei Sachen, die

01:23:43.210 --> 01:23:44.670
noch ein bisschen in diese Funktionen reingehen.

01:23:44.750 --> 01:23:46.810
Wir haben ja Funktionen, jetzt jede Menge so Sachen.

01:23:47.690 --> 01:23:49.390
Was ist dann Lambda-Funktion? Was macht die denn dann?

01:23:49.930 --> 01:23:51.690
Das haben wir, glaube ich, auch schon einmal kurz besprochen.

01:23:52.310 --> 01:23:53.710
Das ist eigentlich nichts Besonderes.

01:23:53.710 --> 01:23:55.910
Das ist eine Funktion,

01:23:56.110 --> 01:23:57.590
wie jede andere. Also was halt in Python

01:23:57.590 --> 01:23:59.410
nicht so richtig schick geht.

01:24:00.210 --> 01:24:00.770
Ich meine ja auch

01:24:00.770 --> 01:24:03.430
ein bisschen JavaScript und das ist da

01:24:03.430 --> 01:24:05.570
so schon ein Stückchen eleganter vielleicht.

01:24:06.810 --> 01:24:07.790
Oder was es

01:24:07.790 --> 01:24:09.430
in Python so nicht gibt, sind so anonyme Blöcke

01:24:09.430 --> 01:24:11.430
oder anonyme Funktionen

01:24:11.430 --> 01:24:12.510
über mehrere Zeilen oder sowas.

01:24:13.390 --> 01:24:14.730
Sondern da gibt es halt Lambda.

01:24:17.350 --> 01:24:19.210
Warum muss das überhaupt sein? Wofür braucht man sowas?

01:24:19.930 --> 01:24:21.230
es gibt oft irgendwie

01:24:21.230 --> 01:24:23.130
Situationen, wo man

01:24:23.130 --> 01:24:25.870
eine Funktion übergeben möchte

01:24:25.870 --> 01:24:28.370
irgendwo hin,

01:24:29.370 --> 01:24:29.950
aber die

01:24:29.950 --> 01:24:30.650
sonst nicht braucht.

01:24:31.750 --> 01:24:33.730
Also ein Beispiel wäre

01:24:33.730 --> 01:24:35.910
jetzt irgendwie, wenn man

01:24:35.910 --> 01:24:37.750
irgendwas mit

01:24:37.750 --> 01:24:40.030
NumPy

01:24:40.030 --> 01:24:41.470
Arrays macht oder so, oder

01:24:41.470 --> 01:24:43.730
DataFrames, da

01:24:43.730 --> 01:24:45.950
ist es ja so, dass man eigentlich keine Vorschleifen

01:24:45.950 --> 01:24:47.610
nicht per Vorschleife über irgendwas

01:24:47.610 --> 01:24:49.830
iterieren kann, weil Vorschleifen

01:24:49.830 --> 01:24:51.770
super langsam sind im Fallen.

01:24:51.830 --> 01:24:52.770
Was jetzt nicht heißen soll.

01:24:54.170 --> 01:24:55.910
Vorschleifen sind halt schon gut, aber wenn man jetzt

01:24:55.910 --> 01:24:58.170
über ein Array mit ein paar Millionen

01:24:58.170 --> 01:25:00.130
Einträgen iteriert, dann will man das vielleicht nicht

01:25:00.130 --> 01:25:02.090
als Vorschleife hinschreiben, sondern was man dann

01:25:02.090 --> 01:25:04.130
hinschreibt, ist halt irgendwas, dataFrame.apply

01:25:04.910 --> 01:25:06.070
und dann übergibt man eine Funktion,

01:25:06.530 --> 01:25:07.990
die dann halt

01:25:07.990 --> 01:25:09.770
das macht, was man jetzt eigentlich

01:25:09.770 --> 01:25:12.250
im Body einer Vorschleife gerne gemacht hätte,

01:25:12.410 --> 01:25:13.490
aber die man ja eigentlich hinschreiben kann.

01:25:14.350 --> 01:25:16.150
Diese Funktion hat aber sonst keinen Zweck.

01:25:16.350 --> 01:25:18.090
Die ist nicht, an anderer Stelle braucht man

01:25:18.090 --> 01:25:19.930
die nicht, weil eigentlich, was man hätte hinschreiben wollen,

01:25:19.990 --> 01:25:21.450
wäre eine Vorschleife gewesen und dann

01:25:21.450 --> 01:25:23.730
das, was man in dieser Vorschleife macht, halt machen.

01:25:24.410 --> 01:25:26.030
Aber das geht halt nicht. Daher

01:25:26.030 --> 01:25:27.610
ja,

01:25:27.830 --> 01:25:29.650
braucht man halt jetzt diese temporäre

01:25:29.650 --> 01:25:31.870
Funktion, der man jetzt auch gar nicht unbedingt einen Namen

01:25:31.870 --> 01:25:33.810
geben will. Man möchte halt quasi die Quadrate

01:25:33.810 --> 01:25:35.770
haben von einer Spalte oder sowas. Irgendwie sowas.

01:25:35.810 --> 01:25:37.770
Oder rechnet halt irgendwas aus auf jedem Element

01:25:37.770 --> 01:25:39.250
oder so. Und dann, genau.

01:25:41.410 --> 01:25:41.770
Lambda

01:25:41.770 --> 01:25:43.890
gibt halt sozusagen,

01:25:44.110 --> 01:25:45.830
also Lambda x Doppelpunkt

01:25:45.830 --> 01:25:49.170
x zum Quadrat

01:25:49.170 --> 01:25:50.970
oder sowas, würde halt

01:25:50.970 --> 01:25:53.070
ein Argument nehmen und dieses

01:25:53.070 --> 01:25:54.910
Argument mit sich selbst multiplizieren und dann wieder

01:25:54.910 --> 01:25:56.770
zurückgeben. Nur dass man halt

01:25:56.770 --> 01:25:58.230
das Return weglassen

01:25:58.230 --> 01:26:00.690
muss. Also Return kann man nicht hinschreiben

01:26:00.690 --> 01:26:02.570
in der Lambda, sondern es ist halt

01:26:02.570 --> 01:26:04.970
das, was halt man, das Letzte,

01:26:05.110 --> 01:26:06.410
was irgendwie...

01:26:06.410 --> 01:26:09.030
Implizit wird das halt einfach

01:26:09.030 --> 01:26:10.590
zurückgegeben. Und

01:26:10.590 --> 01:26:12.890
ja, auch die

01:26:12.890 --> 01:26:14.530
Argumentübergabe ist ein bisschen anders.

01:26:14.750 --> 01:26:16.830
Es ist halt nicht irgendwie Klammer auf und dann irgendwas,

01:26:16.970 --> 01:26:18.550
sondern es ist halt einfach Leerzeichen

01:26:18.550 --> 01:26:20.750
und dann Liste der Argumente,

01:26:20.850 --> 01:26:22.770
Doppelpunkt und das wird halt

01:26:22.770 --> 01:26:24.850
implizit passiert. Und es kann alles

01:26:24.850 --> 01:26:26.110
nur in einer Zeile stehen. Es darf nicht

01:26:26.110 --> 01:26:28.450
mehrere Zeilen.

01:26:28.470 --> 01:26:30.390
Es ist aber so ein bisschen hässlich.

01:26:31.090 --> 01:26:32.930
Auf der anderen Seite ist es so, wenn das komplizierter

01:26:32.930 --> 01:26:34.570
wird, man muss das ja nicht so machen. Man kann auch

01:26:34.570 --> 01:26:36.710
tatsächlich eine Funktion hinschreiben, die man einfach

01:26:36.710 --> 01:26:37.870
irgendwie nennt.

01:26:39.230 --> 01:26:40.270
Kann man ja auch sagen, irgendwie

01:26:40.270 --> 01:26:42.790
rechne mir irgendwie das Quadrat aus

01:26:42.790 --> 01:26:44.190
oder so Funktion.

01:26:44.750 --> 01:26:46.690
Und dann kann man ja auch mehrere

01:26:46.690 --> 01:26:48.550
Zeilen schreiben, die schreibt man dann da rein und dann

01:26:48.550 --> 01:26:50.430
übergibt man das Ding halt. Der Lambda-Funktion?

01:26:51.630 --> 01:26:52.650
Nicht der Lambda-Funktion, sondern

01:26:52.650 --> 01:26:54.710
übergibt das statt der Lambda-Funktion, weil das ist genau

01:26:54.710 --> 01:26:56.670
das Gleiche. Das, was man

01:26:56.670 --> 01:26:58.750
zurückbekommt von diesem Lambda, ist auch nichts. Das heißt, Lambda braucht man

01:26:58.750 --> 01:26:59.530
eigentlich überhaupt nicht.

01:27:00.150 --> 01:27:02.550
Man braucht es nicht. Es ist halt manchmal

01:27:02.550 --> 01:27:04.670
auch nett, das so hinschreiben

01:27:04.670 --> 01:27:06.390
zu können, aber wirklich brauchen tut man es nicht.

01:27:07.630 --> 01:27:08.630
Spart ein bisschen Schreibarbeit

01:27:08.630 --> 01:27:10.870
für zum Beispiel so einfache Operationen wie einfach Quadrat zu geben,

01:27:10.950 --> 01:27:12.470
dann kann man einfach das Lambda in die Zeile schreiben,

01:27:12.470 --> 01:27:13.590
wenn man es nicht wieder sonst braucht.

01:27:14.090 --> 01:27:16.230
Genau, weil du hast halt, wenn du Funktionen

01:27:16.230 --> 01:27:18.010
hinschreibst in Python, immer einen gewissen

01:27:18.010 --> 01:27:20.010
Zeilen-Overhead, weil, naja,

01:27:20.330 --> 01:27:21.570
da die

01:27:21.570 --> 01:27:24.130
Umbrüche syntaktisch relevant

01:27:24.130 --> 01:27:26.110
sind und die Eindrückung, ist es halt so, dass

01:27:26.110 --> 01:27:28.130
du da auf jeden Fall immer mehrere, mindestens mal

01:27:28.130 --> 01:27:29.490
zwei Zeilen für hinschreiben musst.

01:27:30.770 --> 01:27:32.150
Ja, und mit Lambda kannst du es auch in

01:27:32.150 --> 01:27:33.970
einer Zeile hinschreiben. Und wenn das wirklich eine ganz simple

01:27:33.970 --> 01:27:35.950
Geschichte ist, dann willst du vielleicht keine,

01:27:35.950 --> 01:27:37.870
nicht deswegen eine Funktion definieren, sondern

01:27:37.870 --> 01:27:39.550
ja, aber

01:27:39.550 --> 01:27:41.970
letztlich kann man dafür auch ganz normale Funktionen

01:27:41.970 --> 01:27:43.910
verwenden und

01:27:43.910 --> 01:27:45.670
was ja an Python auch geht, was auch schön ist,

01:27:45.750 --> 01:27:47.810
du kannst halt innerhalb von Funktionen auch wieder

01:27:47.810 --> 01:27:49.650
Funktionen definieren. Also du musst ja nicht

01:27:49.650 --> 01:27:51.850
die Funktionen dann außerhalb der Funktionen. Das heißt, du kannst die Funktion

01:27:51.850 --> 01:27:53.570
auch direkt da an die Stelle schreiben, wo

01:27:53.570 --> 01:27:55.750
du sie verwenden willst. Wann macht man das denn

01:27:55.750 --> 01:27:57.470
alle, dass man so schachtelte Funktionen macht?

01:27:57.690 --> 01:27:59.730
Ja, eben. Zum Beispiel, wenn du halt eine Funktion sonst

01:27:59.730 --> 01:28:01.770
nirgendwo verwenden möchtest und möchtest

01:28:01.770 --> 01:28:03.010
halt, aber du brauchst eine Funktion.

01:28:04.170 --> 01:28:05.330
Da sind wir wieder bei, zum Beispiel bei

01:28:05.330 --> 01:28:07.390
Clojures, brauchst du das halt,

01:28:07.890 --> 01:28:09.790
wo du eine Funktion zurückgibst, die halt

01:28:09.790 --> 01:28:11.150
Zugriff auf den Scope

01:28:11.150 --> 01:28:14.330
auf Variablen hat, die im Scope

01:28:14.330 --> 01:28:15.150
dieser Funktion liegen.

01:28:16.390 --> 01:28:17.030
Also wenn du,

01:28:18.770 --> 01:28:19.770
also Clojure ist quasi,

01:28:20.190 --> 01:28:22.250
du hast eine Funktion und in dieser

01:28:22.250 --> 01:28:24.170
Funktion gibst du

01:28:24.170 --> 01:28:25.750
jetzt eine andere Funktion zurück.

01:28:27.250 --> 01:28:27.750
Eine innere

01:28:27.750 --> 01:28:30.230
Funktion sozusagen. Und du möchtest, dass

01:28:30.230 --> 01:28:32.210
diese Funktion Zugriff hat

01:28:32.210 --> 01:28:34.010
auf eine Variable, die zum Beispiel

01:28:34.010 --> 01:28:35.690
innerhalb der äußeren Funktion definiert ist.

01:28:36.010 --> 01:28:38.050
Zum Beispiel ein Counter, der mit

01:28:38.050 --> 01:28:40.210
irgendwas initialisiert wird. Also genau, das Beispiel

01:28:40.210 --> 01:28:41.390
können wir mal nehmen, sagen wir mal

01:28:41.390 --> 01:28:41.890
def

01:28:41.890 --> 01:28:48.250
zähle

01:28:48.250 --> 01:28:49.570
ab, Klammer auf

01:28:49.570 --> 01:28:51.930
x, Klammer zu, Doppelpunkt

01:28:51.930 --> 01:28:54.150
counter gleich

01:28:54.150 --> 01:28:55.790
x und dann def inner

01:28:55.790 --> 01:28:56.810
Klammer auf

01:28:56.810 --> 01:29:02.450
y

01:29:02.450 --> 01:29:05.470
Klammer zu, Doppelpunkt

01:29:05.470 --> 01:29:09.490
und dann return

01:29:09.490 --> 01:29:11.010
Range

01:29:11.010 --> 01:29:12.530
Counter,

01:29:12.910 --> 01:29:15.690
Counter,

01:29:16.230 --> 01:29:16.850
Y oder so.

01:29:17.130 --> 01:29:19.310
Es geht darum, wenn du sagen möchtest,

01:29:19.410 --> 01:29:21.450
ab wann etwas zählen soll, dann möchtest

01:29:21.450 --> 01:29:22.510
du diesen Counter ja

01:29:22.510 --> 01:29:25.210
diesen State wieder halten

01:29:25.210 --> 01:29:27.210
irgendwo und du möchtest ihn irgendwo halten, wo

01:29:27.210 --> 01:29:29.390
jetzt die innere Funktion, die du zurückgibst, die jetzt dann

01:29:29.390 --> 01:29:31.050
irgendwie zum Beispiel irgendwas iteriert oder so,

01:29:31.470 --> 01:29:32.830
darauf zugreifen kann. Aber

01:29:32.830 --> 01:29:35.330
du willst es sonst nicht

01:29:35.330 --> 01:29:37.370
manipulierbar haben. Das ist auch eine, damit kannst

01:29:37.370 --> 01:29:39.370
du tatsächlich dann auch

01:29:39.370 --> 01:29:42.110
Werte so weg verstecken, dass man

01:29:42.110 --> 01:29:43.930
da nicht mehr rankommt. Jedenfalls nicht.

01:29:44.150 --> 01:29:46.150
Also man kommt schon, aber dann wird's schwierig.

01:29:46.690 --> 01:29:47.290
Nicht mehr so einfach.

01:29:49.170 --> 01:29:49.430
Und

01:29:49.430 --> 01:29:52.070
ja, dafür braucht man zum Beispiel so

01:29:52.070 --> 01:29:54.230
innere Funktionen. Ohne die ginge das gar nicht richtig.

01:29:54.570 --> 01:29:56.090
Also, und das nennt man

01:29:56.090 --> 01:29:56.890
das ist eine Clojure.

01:29:57.890 --> 01:29:59.950
Also, dass sozusagen die innere Funktion

01:29:59.950 --> 01:30:01.930
hat Zugriff auf den Counter, den ich irgendwann mal

01:30:01.930 --> 01:30:03.810
übergeben hab. Aber

01:30:03.810 --> 01:30:06.150
weil die innere Funktion

01:30:06.150 --> 01:30:08.150
ja im gleichen Scope ist wie das Ding,

01:30:09.050 --> 01:30:11.350
wie das, was ich ursprünglich mal gesetzt habe.

01:30:13.570 --> 01:30:15.270
Ansonsten komme ich da von außen aber nicht mehr ran.

01:30:15.350 --> 01:30:18.950
Wenn ich jetzt nur die zurückgegebenen Funktionen habe,

01:30:19.430 --> 01:30:21.750
dann komme ich an den Counter-Wert nicht mehr ran.

01:30:23.150 --> 01:30:24.650
Und dann kann ich halt die äußere Funktion verwenden,

01:30:24.750 --> 01:30:27.350
um zu sagen, gib mir einen Counter, der ab 5 zählt immer zurück.

01:30:27.450 --> 01:30:28.970
Oder gib mir einen Counter, der ab 10 zählt immer.

01:30:29.350 --> 01:30:31.610
Und das 10 oder 5 steht dann halt eben in dieser,

01:30:31.610 --> 01:30:34.750
ja, ist ein etwas komplizierteres Konzept, muss man,

01:30:35.050 --> 01:30:37.890
aber das ist halt auch die Art, wie dann irgendwie Dekoratoren

01:30:37.890 --> 01:30:39.130
und

01:30:39.130 --> 01:30:42.950
Context Manager und so

01:30:42.950 --> 01:30:44.470
funktionieren. Die machen da

01:30:44.470 --> 01:30:46.510
Dinge in der Richtung.

01:30:47.790 --> 01:30:47.850
Ja.

01:30:49.550 --> 01:30:50.930
Genau. Aber das

01:30:50.930 --> 01:30:53.110
finde ich auch sehr schön, dass man

01:30:53.110 --> 01:30:54.350
halt in Funktionen auch locker

01:30:54.350 --> 01:30:57.070
Funktionen definieren kann. Man kann auch Klassen innerhalb von

01:30:57.070 --> 01:30:59.110
Klassen definieren und so. Also das

01:30:59.110 --> 01:30:59.990
geht einfach problemlos.

01:31:01.990 --> 01:31:03.430
Klingt nach viel Konfusion

01:31:03.430 --> 01:31:05.230
für die Anfänger, die jetzt gerade da sind.

01:31:05.230 --> 01:31:06.190
Ja, ja, ja. Vielleicht sollte man

01:31:06.190 --> 01:31:08.010
Genau, auch wieder, nee, vielleicht sollte man das

01:31:08.010 --> 01:31:08.710
mal doch nicht haben.

01:31:10.570 --> 01:31:12.370
Ja, ich habe jetzt noch eine

01:31:12.370 --> 01:31:13.970
Basisfrage, was ist der Unterschied von einer

01:31:13.970 --> 01:31:16.010
Zugweisung von gleich-gleich oder

01:31:16.010 --> 01:31:17.610
ist, also nicht zugreifen, sondern

01:31:17.610 --> 01:31:20.090
eine Abfrage, was vergleicht man

01:31:20.090 --> 01:31:21.650
ein gleich-gleich oder ein ist? Also zum Beispiel

01:31:21.650 --> 01:31:24.090
A gleich-gleich, B A ist B, etwas ist

01:31:24.090 --> 01:31:25.950
gleich-gleich, non, ist non.

01:31:27.050 --> 01:31:27.250
Ja,

01:31:27.830 --> 01:31:28.790
also

01:31:28.790 --> 01:31:31.150
wenn

01:31:31.150 --> 01:31:33.370
ich gleich-gleich verwendere,

01:31:33.710 --> 01:31:35.250
also gleich ist natürlich irgendwie

01:31:35.250 --> 01:31:36.990
Zuweisungen, aber gleich, gleich,

01:31:37.130 --> 01:31:39.090
da wird halt der Wert verglichen.

01:31:39.450 --> 01:31:39.550
Also

01:31:39.550 --> 01:31:45.170
und bei is wird

01:31:45.170 --> 01:31:47.170
verglichen, ob es das gleiche Objekt

01:31:47.170 --> 01:31:48.810
ist. Und deswegen

01:31:48.810 --> 01:31:51.210
bei none sagt man immer is none, weil

01:31:51.210 --> 01:31:53.130
es nur ein none-Objekt gibt. Genau, none

01:31:53.130 --> 01:31:53.670
ist ein Singleton.

01:31:55.270 --> 01:31:57.090
Und deswegen kann ich halt so testen,

01:31:57.290 --> 01:31:58.930
ob es wirklich none ist.

01:31:59.630 --> 01:32:00.730
True und false sind auch Singleton.

01:32:05.250 --> 01:32:10.110
ja

01:32:10.110 --> 01:32:12.410
bin ich mir jetzt nicht so ganz sicher, aber

01:32:12.410 --> 01:32:13.430
ich glaube schon

01:32:13.430 --> 01:32:16.150
ich weiß aber nicht

01:32:16.150 --> 01:32:18.610
ja, so müsste wahrscheinlich so sein, das könnte eigentlich

01:32:18.610 --> 01:32:19.130
gar nicht anders

01:32:19.130 --> 01:32:22.170
okay, das heißt, er müsste halt tatsächlich, wenn er ist,

01:32:22.250 --> 01:32:23.310
genau das Objekt

01:32:23.310 --> 01:32:25.630
ich weiß nicht, man kann das

01:32:25.630 --> 01:32:28.410
aber man kann das auch zuweisen, also es ist auch ganz böse

01:32:28.410 --> 01:32:30.590
man kann True und False auch noch anders

01:32:30.590 --> 01:32:31.270
belegen, also

01:32:31.270 --> 01:32:33.830
müsste man mal nachgucken, ich weiß nicht genau

01:32:33.830 --> 01:32:36.370
was irgendwie spannend ist, weil jetzt, wir haben ja so ein paar

01:32:36.370 --> 01:32:38.230
mal über so Sachen geredet, was jetzt irgendwie Klassen sind

01:32:38.230 --> 01:32:40.350
und Objekte und Typen, dass alle Sachen in Python

01:32:40.350 --> 01:32:41.810
irgendwelche Objekte sind, irgendwelche Typen sind.

01:32:42.210 --> 01:32:43.830
Und dann habe ich mich irgendwie gefragt, ob

01:32:43.830 --> 01:32:46.250
jetzt nicht die ganzen Zuweisungen, also man kann

01:32:46.250 --> 01:32:48.250
jetzt irgendwie Typen umwandeln, ja, also von Integer

01:32:48.250 --> 01:32:50.210
auf String oder sowas, ob das nicht halt auch

01:32:50.210 --> 01:32:52.270
eine Klasse

01:32:52.270 --> 01:32:54.090
dann eigentlich ist, die man dann halt nimmt, weil das halt

01:32:54.090 --> 01:32:55.950
ein Typ ist, ein Objekt ist, deswegen müsste das eigentlich

01:32:55.950 --> 01:32:57.870
großgeschrieben werden, weil man halt eine Instanz

01:32:57.870 --> 01:33:00.250
eines Objektes ändert und eine Instanz eines Objektes erzeugt.

01:33:00.470 --> 01:33:02.070
Zum Beispiel von einer Instanz eines Objektes

01:33:02.070 --> 01:33:04.030
String, eine Instanz, also wenn man das Integer wechselt,

01:33:04.050 --> 01:33:05.950
wenn man ein Inter vorstellt, es muss ein bisschen großes Int sein,

01:33:06.710 --> 01:33:07.770
dann an der Stelle irgendwie

01:33:07.770 --> 01:33:08.930
war ich dann ein bisschen verwirrt.

01:33:09.070 --> 01:33:11.630
Ja, also ich rate jetzt mal,

01:33:11.890 --> 01:33:14.150
woher das kommt. Ich weiß es ehrlich gesagt auch nicht so genau.

01:33:15.990 --> 01:33:18.090
Vielleicht weiß das jemand besser und kann mich da korrigieren,

01:33:18.190 --> 01:33:19.830
aber ich denke mal, es liegt daran,

01:33:20.170 --> 01:33:21.450
dass das Build-Ins sind.

01:33:22.750 --> 01:33:24.190
Also ja, eigentlich die Konvention in Python

01:33:24.190 --> 01:33:26.090
ist so, wenn es eine Klasse ist, dann schreibt man das halt

01:33:26.090 --> 01:33:28.190
groß, aber

01:33:28.190 --> 01:33:30.290
ich glaube,

01:33:30.390 --> 01:33:31.330
alle Build-Ins sind klein.

01:33:32.070 --> 01:33:39.210
Und da das Build-Ins sind, sagt man eher, das ist wichtiger, weil es gibt nicht so viele Build-Ins.

01:33:39.210 --> 01:33:49.390
Aber richtig wäre es tatsächlich, dass man, zum Verständnis vielleicht, dass man irgendwie, wenn man einen Typ ändert, einer Variable beispielsweise, dass man einen neuen Instanz, eine neue oder eine andere Klasse erzeugt.

01:33:49.390 --> 01:33:51.630
Ja, ja, das ist so, aber das passiert auch tatsächlich.

01:33:51.770 --> 01:33:54.410
Also wenn ich sage int, Klammer auf, 5, Klammer zu,

01:33:55.190 --> 01:33:59.230
dann wird ein neues Integer-Objekt erzeugt, genau, mit dem Wort 5.

01:34:00.330 --> 01:34:06.730
Also es ist tatsächlich, ja, auch Dict ist ja eine Klasse tatsächlich.

01:34:07.010 --> 01:34:08.930
Ich kann ja auch davon erben und so, sollte ich vielleicht nicht machen,

01:34:09.350 --> 01:34:13.430
aber ich kann davon erben und das funktioniert auch.

01:34:15.390 --> 01:34:17.690
Aber ja, ich denke, das hängt damit zusammen,

01:34:17.750 --> 01:34:19.610
dass die Build-Insights so Spezialfälle sind.

01:34:20.030 --> 01:34:21.250
Wenn ich die Klassen verwenden möchte,

01:34:21.290 --> 01:34:23.110
für die ganzen Dinger gibt es auch noch richtige Klassen.

01:34:24.510 --> 01:34:28.770
Zum Beispiel für Dikt und List und so

01:34:28.770 --> 01:34:30.250
gibt es UserDikt und UserList.

01:34:31.430 --> 01:34:34.350
Und auch wenn ich jetzt irgendwie selber ein eigenes Dikt,

01:34:34.550 --> 01:34:36.710
das Dinge ein bisschen anders macht als ein normales Dikt,

01:34:37.290 --> 01:34:38.050
verwenden möchte,

01:34:38.210 --> 01:34:41.470
dann sollte ich halt irgendwie von UserDikt erben

01:34:41.470 --> 01:34:43.570
und nicht von einfach nur kleingeschriebenem Dikt.

01:34:45.550 --> 01:34:47.510
Dass die das nie, weil sich schon Leute

01:34:47.510 --> 01:34:49.470
darum gekümmert haben, bestimmte Probleme zu umgehen, auf die man

01:34:49.470 --> 01:34:50.370
dann stößt, wenn man das nicht macht.

01:34:50.530 --> 01:34:50.890
Ja, genau.

01:34:53.290 --> 01:34:55.390
Ja, jetzt haben wir

01:34:55.390 --> 01:34:57.350
noch jede Menge, ich weiß gar nicht, ob wir das heute

01:34:57.350 --> 01:34:58.650
in der Folge alles irgendwie unterkriegen.

01:34:59.290 --> 01:35:01.530
Noch einer hat gefragt, was denn eine Shallow Copy ist.

01:35:02.550 --> 01:35:02.690
Achso.

01:35:03.630 --> 01:35:05.230
Wie arbeitet man richtig mit Listen im Zusammenhang

01:35:05.230 --> 01:35:07.010
mit Funktionen? Gibt man eine Kopie und

01:35:07.010 --> 01:35:09.190
retürnt eine neue Liste oder gibt man eine Liste und

01:35:09.190 --> 01:35:10.630
ändert die quasi in Plays?

01:35:11.510 --> 01:35:12.250
Was hat das damit zu tun?

01:35:12.250 --> 01:35:12.770
Also irgendwie.

01:35:15.550 --> 01:35:21.670
Ja, das ist auch eine unter Umständen Stilfrage, was man da machen möchte.

01:35:23.710 --> 01:35:27.410
Also einmal, vielleicht zuerst das mit der Shallow-Kopie.

01:35:28.210 --> 01:35:33.770
Also die Frage ist, was passiert eigentlich, wenn ich jetzt sozusagen eine Kopie von irgendwas machen möchte,

01:35:33.770 --> 01:35:44.050
und weil ich warum auch immer irgendwie eine zweite Version von irgendeiner Datenstruktur brauche oder so,

01:35:45.070 --> 01:35:47.970
Da ist es, wenn ich jetzt die einfach nur kopiere,

01:35:48.170 --> 01:35:51.570
also in Python habe ich eigentlich immer Referenzen

01:35:51.570 --> 01:35:53.270
auf solche Datenstrukturen in der Hand.

01:35:54.150 --> 01:35:57.530
Also auch die Übergabe von Sachen ist immer bei Referenz.

01:35:57.610 --> 01:35:59.390
Also es gibt ja ein C, es ist unter Umständen anders.

01:35:59.390 --> 01:36:03.370
Da kann ich Argumente übergeben als Referenz

01:36:03.370 --> 01:36:09.810
oder halt als Wert, also direkt den Wert einfach so.

01:36:10.490 --> 01:36:12.670
Und in Python ist es immer per Referenz.

01:36:13.610 --> 01:36:20.070
Also in der Variable, die ich übergebe, steht immer sozusagen einfach eine Speicheradresse drin, die halt auf das Objekt zeigt, das ich übergebe.

01:36:20.530 --> 01:36:24.830
Und ich übergebe immer nur die Adresse, ich übergebe nicht der Funktion das Objekt selbst.

01:36:26.250 --> 01:36:34.010
Und jetzt ist es halt so, wenn ich einfach nur, bestimmte Operationen duplizieren mir halt jetzt diese Adresse, aber nicht den Inhalt dahinter.

01:36:34.810 --> 01:36:39.550
Das heißt, wenn ich jetzt, ich mache eine Kopie davon, ich muss mal überlegen, in welchen Umständen ich das hinkriege.

01:36:42.370 --> 01:37:02.910
Wenn ich jetzt einfach nur kopiere, dann kann es sein, dass mir nur die Referenz kopiert wird. Das heißt, mir wird halt die Speicheradresse in eine andere Variable kopiert, aber wenn ich jetzt irgendwas am Inhalt einer Liste oder so ändere, dann ist das in beiden Listen geändert.

01:37:02.910 --> 01:37:14.130
Und das ist unter Umständen nicht so intuitiv. Vielleicht hätte man jetzt nicht so mit gerechnet, sondern man hätte damit gerechnet, dass ich jetzt zwei Listen habe, die im Hauptspeicher an zwei unterschiedlichen Stellen liegen.

01:37:15.310 --> 01:37:42.750
Und eine Shallow-Kopie ist halt eine, die nur sozusagen, also bei einer Liste könnte ich mir jetzt sogar vorstellen, dass es oft, wenn ich jetzt nochmal eine Liste drumherum schreibe oder so, dass dann tatsächlich eine Kopie erzeugt wird, also eine Nicht-Shallow-Kopie, aber wenn ich jetzt eine komplizierte Datenstruktur habe in irgendeinem Dikt oder so, wo viele Sachen ineinander verschachtelt drin liegen, dann ist es so, wenn ich jetzt sage Dikt von dem Ding, dann ist es eine, oder wenn ich sage Kopie, dann ist das eine Shallow-Kopie.

01:37:44.750 --> 01:37:47.210
Warum brauche ich dann überhaupt

01:37:47.210 --> 01:37:49.050
eine Schellokopie? Dann könnte ich auch einfach auf das normale Dikt zeigen,

01:37:49.090 --> 01:37:50.250
wenn es eh nur auf das gleiche Objekt zeigt.

01:37:50.610 --> 01:37:52.450
Das ist eigentlich nur eine andere Benennung.

01:37:52.930 --> 01:37:55.250
Wenn ich die Inhalte mit kopieren will,

01:37:55.450 --> 01:37:59.270
dann gibt es

01:37:59.270 --> 01:37:59.770
zum Beispiel

01:37:59.770 --> 01:38:02.950
eine Funktion aus dem Copy,

01:38:03.010 --> 01:38:04.430
ich glaube, das ist Standardbibliothek,

01:38:04.770 --> 01:38:06.490
dann sagt man immer FormCopy, ImportDeepCopy

01:38:06.490 --> 01:38:08.790
und dann sagt man DeepCopy, irgendwie

01:38:08.790 --> 01:38:11.190
komplizierte, dick verschachtelte Datenstruktur

01:38:11.190 --> 01:38:13.070
und die geht dann rekursiv

01:38:13.070 --> 01:38:14.930
da durch und kopiert den ganzen Kram da raus

01:38:14.930 --> 01:38:16.950
in eine andere Datenstruktur. Und dann habe ich halt

01:38:16.950 --> 01:38:18.890
das tatsächlich getrennt voneinander. Aber

01:38:18.890 --> 01:38:20.670
ansonsten ist das halt nicht so einfach.

01:38:20.850 --> 01:38:21.450
Wenn ich da

01:38:21.450 --> 01:38:25.050
Dict drumherum mache, dann kann es

01:38:25.050 --> 01:38:26.770
zwar auch sein, dass es ein neues Dict ist an einer anderen

01:38:26.770 --> 01:38:29.130
Speicheradresse und dass ich

01:38:29.130 --> 01:38:30.890
die Keys und Values kopiert habe, aber

01:38:30.890 --> 01:38:32.790
die Values waren halt Referenzen auf irgendwas

01:38:32.790 --> 01:38:34.870
und die Objekte hinter diesen Referenzen haben sich

01:38:34.870 --> 01:38:36.990
halt nicht geändert. Und das kann halt sehr...

01:38:36.990 --> 01:38:38.810
Da kann man sich so ein bisschen mit am Fuß schießen, wenn man so was

01:38:38.810 --> 01:38:40.870
übergibt wie leere Listen als Standardwert vom

01:38:40.870 --> 01:38:43.010
Keyword. Ja, da kann man sich

01:38:43.010 --> 01:38:45.210
böse in den Fuß schießen mit. Weil dann, also das ist glaube ich

01:38:45.210 --> 01:38:47.130
generell das Problem, also bei so

01:38:47.130 --> 01:38:49.010
ein paar Sachen, die man als Keyword setzt, ja, wenn man

01:38:49.010 --> 01:38:50.870
irgendwie eine Funktion hat, da wird ein Keyword

01:38:50.870 --> 01:38:52.510
übergeben, das setzt man einem Default-Wert,

01:38:52.930 --> 01:38:54.930
indem es zum Beispiel eine leere Liste hat oder einen

01:38:54.930 --> 01:38:56.870
random initialisierten Wert oder sowas,

01:38:57.450 --> 01:38:58.870
der wird halt beim ersten Mal dann

01:38:58.870 --> 01:39:00.830
initialisiert und da steht dann halt aber in der Speicheradresse

01:39:00.830 --> 01:39:02.950
dieser Wert drin, der dann halt dem zugewiesen ist schon,

01:39:03.290 --> 01:39:04.930
weil das halt dann nur darauf zeigt und halt nicht

01:39:04.930 --> 01:39:06.930
jedes Mal ein neues Objekt generiert und das

01:39:06.930 --> 01:39:08.590
heißt, man hat immer dieselbe leere Liste,

01:39:09.130 --> 01:39:10.770
die dann vielleicht nicht mehr leer ist, nachdem man die Funktion

01:39:10.770 --> 01:39:12.550
einmal aufgerufen hat und dann...

01:39:12.550 --> 01:39:14.910
Und dann ist es immer die gleiche und dann funktioniert es sogar oft

01:39:14.910 --> 01:39:16.750
und dann irgendwann fällt es einem ganz

01:39:16.750 --> 01:39:18.170
furchtbar auf den Fuß und man weiß nicht genau,

01:39:18.270 --> 01:39:20.810
an solchen Problemen habe ich auch schon lange

01:39:20.810 --> 01:39:22.690
rumgedebugt, bis ich mir dann so, oh nein,

01:39:22.750 --> 01:39:24.110
das ist immer die gleiche Liste, oh scheiße.

01:39:25.050 --> 01:39:26.270
Und da ist auch da

01:39:26.270 --> 01:39:28.510
eine Konvention, dass man das eben eigentlich,

01:39:28.670 --> 01:39:30.530
dass man nicht als Default-Argument

01:39:30.530 --> 01:39:32.630
in eine Funktion reinschreibt,

01:39:32.750 --> 01:39:33.410
irgendwie

01:39:33.410 --> 01:39:36.450
Default gleich

01:39:36.450 --> 01:39:38.230
Klammer auf, Klammer zu oder so.

01:39:38.510 --> 01:39:40.950
Man sagt immer None und dann macht man eine Überprüfung,

01:39:41.050 --> 01:39:43.090
Und dann ersetzt man die Liste neu.

01:39:43.130 --> 01:39:44.630
Das ist halt echt nur eine böse Fußange.

01:39:45.130 --> 01:39:48.250
Das kann einen schwer erwischen.

01:39:49.330 --> 01:39:50.950
Ja, bei Random-Werten übrigens genau dasselbe.

01:39:51.090 --> 01:39:53.150
Also wenn ihr jetzt irgendwo so ein Zufallswert generieren lassen wollt,

01:39:53.250 --> 01:39:55.630
wie von Random-Rant 1 bis 10 oder sowas,

01:39:55.730 --> 01:39:56.970
und dann habt ihr ihn einmal initialisiert,

01:39:57.010 --> 01:39:58.630
der gibt nicht jedes Mal, wenn ihr die Funktion aufruft,

01:39:58.690 --> 01:39:59.970
einen default neuen Zufallswert zurück,

01:40:00.290 --> 01:40:01.330
sondern immer dasselbe.

01:40:01.510 --> 01:40:04.070
Also das ist an der Stelle nicht intuitiv.

01:40:04.170 --> 01:40:05.410
Also fand ich auch sehr komisch,

01:40:05.510 --> 01:40:07.910
dass er dann nicht einfach jedes Mal beim Aufrufen das neu initialisiert,

01:40:07.910 --> 01:40:09.190
sondern dass er halt dann die Objekte nimmt,

01:40:09.310 --> 01:40:10.830
die er einmal schon irgendwo liegen hat.

01:40:11.050 --> 01:40:35.850
Ja, also eine Geschichte, also List Comprehension macht immer eine Kopie, wenn man zum Beispiel eine neue Liste erzeugt, ansonsten die Kopie aus dem Kopiemodul, wenn es kompliziertere Datenstrukturen sind, dann muss man sich das nicht selber, ich meine, es ist ja wirklich kompliziert, man muss halt rekursiv durchgehen und das will man ja vielleicht auch nicht selber schreiben und da gibt es halt schon ein Ding für, was man da benutzen kann.

01:40:36.090 --> 01:40:57.110
Dann ist es so, naja, was diese unterschiedlichen Stile angeht, also wenn man sich so ein bisschen anguckt, es gibt ja unterschiedliche Arten zu programmieren, so Imperativ, ich würde auch Python eher, auch wenn man es auch mit Berechtigung sagen kann, ist es auch irgendwie eine funktionale Programmiersprache, ist es doch eher, die meisten Leute verwenden es halt irgendwie Imperativ.

01:40:59.550 --> 01:41:14.510
Und in dem Lager sozusagen Paradigma der funktionalen Programmiersprachen ist es aber eher so, dass man halt da und nicht nur da, das setzt sich auch in anderen Bereichen durch. In JavaScript sehen wir das in letzter Zeit oft, auch wenn es um so State-Handling-Geschichten geht.

01:41:14.510 --> 01:41:34.310
Da gibt es dann Redux und so, dass man, wenn man jetzt solche Sachen handelt, versucht immer nur mit Datenstrukturen zu arbeiten, die nicht veränderbar sind, also die mutable sind und immer nur Kopien erzeugt, wenn man irgendwas ändert.

01:41:34.310 --> 01:41:48.190
Also man ändert nichts in einer bestimmten Datenstruktur, sondern man erzeugt eine neue Kopie und an der ändert man dann halt irgendwas, beziehungsweise man ändert nichts, sondern man baut es dann halt neu.

01:41:51.070 --> 01:41:52.610
Was halt diverse, sehr, sehr

01:41:52.610 --> 01:41:55.010
coole Nebeneffekte hat. Unter anderem,

01:41:55.130 --> 01:41:56.970
dass ich Sachen dann perfekt parallelisieren kann,

01:41:58.030 --> 01:41:59.190
dass ich

01:41:59.190 --> 01:42:00.630
weiß, dass ich keine Seiteneffekte habe,

01:42:00.770 --> 01:42:02.910
dass ich super testen kann.

01:42:05.490 --> 01:42:06.850
Es hat eine Menge

01:42:06.850 --> 01:42:08.850
und immer wenn Leute, die aus so einer

01:42:08.850 --> 01:42:10.890
funktionalen Ecke kommen, sehen, was man so

01:42:10.890 --> 01:42:12.610
in Python imperativ macht, dass man irgendwie

01:42:12.610 --> 01:42:15.070
Attribute von irgendwelchen Objekten ändert oder halt

01:42:15.070 --> 01:42:16.750
irgendwie ein Dicte übergeben bekommt,

01:42:16.750 --> 01:42:18.730
das dann irgendwie ein Ende hat

01:42:18.730 --> 01:42:19.150
und dann

01:42:19.150 --> 01:42:22.530
würde man jetzt in funktionaler

01:42:22.530 --> 01:42:24.150
richtigen

01:42:24.150 --> 01:42:26.910
Funktionalen Programmiersprache

01:42:26.910 --> 01:42:28.290
würde man nie irgendwie

01:42:28.290 --> 01:42:30.630
einen Dikt oder eine Liste oder sowas in der

01:42:30.630 --> 01:42:32.610
Funktion nehmen, da irgendwas dran ändern und

01:42:32.610 --> 01:42:34.490
das Ding dann wieder zurückgeben oder so, oder am besten

01:42:34.490 --> 01:42:35.970
gar nicht zurückgeben, sondern einfach nur ändern.

01:42:36.810 --> 01:42:38.470
Sondern man würde immer, wenn man was

01:42:38.470 --> 01:42:39.730
ändert, eine neue Kopie zurückgeben.

01:42:41.290 --> 01:42:42.650
Weil man dann halt diesen ganzen schönen

01:42:42.650 --> 01:42:44.490
Effekt hat, was, wenn man das nicht

01:42:44.490 --> 01:42:46.430
tut, was, würde ich sagen, aber

01:42:46.430 --> 01:42:47.610
in Python oft so ist,

01:42:48.130 --> 01:42:50.350
also man übergibt irgendwo

01:42:50.350 --> 01:42:52.450
eine Liste und dann ändert man irgendwie ein Element

01:42:52.450 --> 01:42:54.070
in dieser Liste und dann gibt man die Liste wieder zurück,

01:42:55.250 --> 01:42:56.290
dann gehen ganz viele

01:42:56.290 --> 01:42:58.450
schöne Sachen nicht mehr, weil dann ist es halt

01:42:58.450 --> 01:42:59.010
ja.

01:43:00.930 --> 01:43:02.610
Man hat vielleicht irgendwas kaputt gemacht.

01:43:03.070 --> 01:43:03.250
Ja.

01:43:03.930 --> 01:43:06.010
Was auf der anderen Seite manchmal halt auch total

01:43:06.010 --> 01:43:08.210
viel einfacher macht, als wenn man

01:43:08.210 --> 01:43:10.110
es funktional schreibt und auch

01:43:10.110 --> 01:43:12.010
effizienter, weil einmal ist es so,

01:43:12.310 --> 01:43:14.230
man kann halt Dinge nicht mehr so richtig direkt beeinflussen

01:43:14.230 --> 01:43:16.030
und es ist halt so,

01:43:16.110 --> 01:43:18.030
wenn man alles immer kopiert und jetzt

01:43:18.030 --> 01:43:20.010
man aber jetzt große Datenmengen hat,

01:43:20.050 --> 01:43:21.850
zum Beispiel im Data-Science-Bereich ist es halt, wenn

01:43:21.850 --> 01:43:24.070
deine Datenstrukturen alle hunderte Megabyte groß sind

01:43:24.070 --> 01:43:25.930
und du machst immer Kopien von allem,

01:43:26.010 --> 01:43:27.990
was auch, also tatsächlich, Pandas

01:43:27.990 --> 01:43:29.470
macht das auch per Default, wenn

01:43:29.470 --> 01:43:31.850
alle Operationen gehen, immer Kopien zurück.

01:43:32.990 --> 01:43:34.130
Aber das kann auch ganz schön

01:43:34.130 --> 01:43:35.970
in den Hauptspeicher gehen. Manchmal muss man dann schon

01:43:35.970 --> 01:43:38.010
sagen, so, ja, hier bitte nicht kopieren, das geht einfach

01:43:38.010 --> 01:43:39.730
nicht, passt dann nicht mehr. Und dann

01:43:39.730 --> 01:43:41.330
muss man halt

01:43:41.330 --> 01:43:43.350
Sachen direkt

01:43:43.350 --> 01:43:45.910
in place ändern oder so und das ist natürlich

01:43:45.910 --> 01:43:47.470
immer ein bisschen schmutzig, aber ja.

01:43:48.030 --> 01:43:49.590
Weekend 30, ja, ja.

01:43:50.350 --> 01:43:51.570
Dunkle Magie, wieder.

01:43:52.950 --> 01:43:54.370
Ja, also hängt davon ab, würde ich sagen,

01:43:54.410 --> 01:43:55.850
was man für ein Problem hat und

01:43:55.850 --> 01:43:58.190
also wenn man das nicht kennt, dann sich mal so

01:43:58.190 --> 01:44:00.290
anzugucken, wie man mit alten Datenstrukturen

01:44:00.290 --> 01:44:02.170
einfach nur Immutable irgendwie hält

01:44:02.170 --> 01:44:03.250
und immer kopieren soll, das ist eigentlich schon

01:44:03.250 --> 01:44:05.290
sehr schick, aber...

01:44:05.290 --> 01:44:08.710
Dann schließ direkt an, was ist denn deine Lieblingsdatenstruktur?

01:44:09.930 --> 01:44:10.830
Meine Lieblingsdatenstruktur?

01:44:10.950 --> 01:44:12.350
Also ich tatsächlich, ja,

01:44:12.530 --> 01:44:12.690
Dict.

01:44:14.310 --> 01:44:16.070
Hätte ich jetzt auch gesagt, früher fand ich Listen ganz toll Dict,

01:44:16.190 --> 01:44:17.470
aber ich auch.

01:44:18.030 --> 01:44:19.230
Vielleicht ein bisschen, wo man gerade ist, ja.

01:44:20.110 --> 01:44:22.290
Und vor allen Dingen ist die Dict-Inflamentation

01:44:22.290 --> 01:44:23.830
in Python ist halt auch total super.

01:44:24.230 --> 01:44:25.030
Also die ist richtig schnell.

01:44:26.670 --> 01:44:28.030
Die ist halt

01:44:28.030 --> 01:44:29.290
ein sehr effizientes Ding und

01:44:29.290 --> 01:44:32.130
ein Riesenhaufen Probleme lassen sich dadurch schon lösen.

01:44:32.310 --> 01:44:33.950
Also wenn man das ordentlich verwendet,

01:44:34.030 --> 01:44:36.030
dann kriegt man da so einen sehr

01:44:36.030 --> 01:44:38.010
großen Teil der so 0815

01:44:38.010 --> 01:44:39.870
Programmiergeschichten, die man so macht, kriegt man halt mit

01:44:39.870 --> 01:44:41.050
Listen und Dicts irgendwie abgebildet.

01:44:42.910 --> 01:44:43.810
Listen braucht man auch,

01:44:44.050 --> 01:44:45.590
halt gerade, wenn man irgendwelche Dinge

01:44:45.590 --> 01:44:47.830
iteriert und so, aber Dicts ist

01:44:47.830 --> 01:44:49.770
halt das Schöne daran ist, dass man halt irgendwie

01:44:49.770 --> 01:44:51.730
sozusagen beliebige Dinge irgendwie speichern

01:44:51.730 --> 01:44:53.610
kann und man kann die

01:44:53.610 --> 01:44:55.730
Namen,

01:44:55.850 --> 01:44:57.810
unter denen man das findet, dann halt irgendwie dynamisch

01:44:57.810 --> 01:44:59.810
generieren und muss das halt nicht vorher definiert

01:44:59.810 --> 01:45:00.330
haben in Code.

01:45:03.090 --> 01:45:03.450
Und

01:45:03.450 --> 01:45:05.750
wann nutzt man denn Tuple, das Datentruktur, wenn man eine Liste

01:45:05.750 --> 01:45:07.730
hat? Also warum ist das überhaupt? Ja, Tuple

01:45:07.730 --> 01:45:09.190
sind halt

01:45:09.190 --> 01:45:11.690
immutable, ja genau. Das ist

01:45:11.690 --> 01:45:12.650
halt der Grund, deswegen

01:45:12.650 --> 01:45:15.750
an den Stellen, wo man es halt immutable

01:45:15.750 --> 01:45:17.750
haben will, dann kann man die halt gut nehmen.

01:45:17.830 --> 01:45:19.670
unter anderem zum Beispiel, wenn du halt

01:45:19.670 --> 01:45:22.250
möchtest, dass etwas key in einem Dikt

01:45:22.250 --> 01:45:23.790
sein kann. Das geht halt mit einer Liste nicht.

01:45:24.670 --> 01:45:25.730
Da musst du halt einen Tuppel nehmen.

01:45:28.470 --> 01:45:30.190
Oder halt bei so Geschichten

01:45:30.190 --> 01:45:31.750
wie Tuppel, Unpacking und so,

01:45:32.030 --> 01:45:33.450
das geht auch nur mit...

01:45:33.450 --> 01:45:35.190
Unpacking geht auch mit Listen, ja.

01:45:35.610 --> 01:45:38.010
Klar, das geht auch mit Listen, aber ich weiß, ich überlege jetzt gerade,

01:45:38.090 --> 01:45:39.370
ob es einen tieferen Grund gibt, warum

01:45:39.370 --> 01:45:42.210
Argumente ein Tuppel sind.

01:45:44.390 --> 01:45:45.910
Also, ja.

01:45:47.830 --> 01:45:49.790
generell. Also Dickey war vielleicht

01:45:49.790 --> 01:45:50.490
eine gute Idee, ja.

01:45:51.490 --> 01:45:53.590
Es gibt schon den

01:45:53.590 --> 01:45:55.390
Fall öfter mal, dass man das halt nicht

01:45:55.390 --> 01:45:57.430
änderbar haben will und dann nimmt man halt ein Doppel

01:45:57.430 --> 01:45:59.750
statt eine Liste. Aber tatsächlich

01:45:59.750 --> 01:46:00.810
ist es so, es gibt auch

01:46:00.810 --> 01:46:03.770
Skalare, sozusagen einfache Werte

01:46:03.770 --> 01:46:05.550
irgendwie, also sowas wie eine 5 oder

01:46:05.550 --> 01:46:08.810
String, wobei

01:46:08.810 --> 01:46:13.730
Listen und Dics ist halt auch so das, was man

01:46:13.730 --> 01:46:15.170
in allen Programmiersprachen irgendwie oder

01:46:15.170 --> 01:46:17.350
vor allen Dingen in allen Skriptsprachen irgendwie eingebaut

01:46:17.350 --> 01:46:19.390
findet, ja, das hast du halt auch in Perl und in PHP

01:46:19.390 --> 01:46:21.350
und in JavaScript, die

01:46:21.350 --> 01:46:23.010
heißen halt in allen diesen

01:46:23.010 --> 01:46:25.190
Programmiersprachen irgendwie ein bisschen anders, ne, in Perl

01:46:25.190 --> 01:46:26.290
heißt es halt Hash und

01:46:26.290 --> 01:46:29.150
Array, ja, in PHP heißt es

01:46:29.150 --> 01:46:31.050
Assoziatives

01:46:31.050 --> 01:46:31.590
Array

01:46:31.590 --> 01:46:34.730
und in, weiß ich nicht,

01:46:35.510 --> 01:46:37.050
JavaScript heißt es halt Object

01:46:37.050 --> 01:46:37.550
und

01:46:37.550 --> 01:46:41.110
ich glaube, da heißt es aber dann auch Array, ja.

01:46:41.450 --> 01:46:42.570
Naja, aber

01:46:42.570 --> 01:46:45.110
diese Grunddatentypen hast du halt

01:46:45.110 --> 01:46:46.370
überall, deswegen war das halt,

01:46:46.830 --> 01:46:48.070
Damit kannst du halt schon eine Menge machen.

01:46:48.790 --> 01:46:51.170
Und Tupple gibt es halt eigentlich, glaube ich, nur in Python

01:46:51.170 --> 01:46:53.070
und anderswo nicht, weil es auch

01:46:53.070 --> 01:46:54.730
sonst nicht so häufig verwendet wird.

01:46:55.830 --> 01:46:56.990
Ist halt schon eher so ein bisschen

01:46:56.990 --> 01:46:57.630
Spezialfall.

01:46:58.750 --> 01:47:01.110
Ja, es gibt auch

01:47:01.110 --> 01:47:02.670
oft von den ganzen

01:47:02.670 --> 01:47:06.950
also was auch mittlerweile, glaube ich,

01:47:06.950 --> 01:47:08.650
ein integrierter Datentyp ist, ist halt

01:47:08.650 --> 01:47:09.370
Set in Python.

01:47:10.310 --> 01:47:12.710
Das ist auch eine Datenstruktur, die wir

01:47:12.710 --> 01:47:14.850
relativ häufig, oder ich benutze sie relativ häufig

01:47:14.850 --> 01:47:16.550
und von denen gibt es halt dann auch

01:47:16.550 --> 01:47:18.410
Immutable-Varianten. Ich weiß jetzt gar nicht, ob es

01:47:18.410 --> 01:47:19.430
Immutable-Tickets gibt,

01:47:20.590 --> 01:47:22.750
aber zum Beispiel von Sets gibt es halt Frozen-Set,

01:47:22.950 --> 01:47:24.650
eben auch für solche Fälle, wie du möchtest,

01:47:24.770 --> 01:47:26.650
dass es irgendwie als Key in ein Ticket ist

01:47:26.650 --> 01:47:28.370
oder so. Und

01:47:28.370 --> 01:47:29.930
den kannst du halt dann nicht mehr verändern.

01:47:31.290 --> 01:47:32.810
Vielleicht gibt es auch sowas wie eine Frozen-List,

01:47:32.910 --> 01:47:33.410
ich weiß nicht genau.

01:47:35.170 --> 01:47:36.590
Aber Frozen-Set benutze ich tatsächlich

01:47:36.590 --> 01:47:37.790
ab und zu. Frozen-List ist Tupel?

01:47:38.530 --> 01:47:40.650
Ja, könnte sein, genau. Frozen-List ist Tupel, ja, genau.

01:47:40.650 --> 01:47:41.650
Ja, ja.

01:47:43.790 --> 01:47:44.230
Okay.

01:47:44.730 --> 01:47:46.350
Wann nutzt man denn Manant Nampai Erase?

01:47:47.090 --> 01:47:48.510
Ja, immer dann, wenn man halt

01:47:48.510 --> 01:47:50.330
sozusagen

01:47:50.330 --> 01:47:54.610
so viele Daten hat, dass es

01:47:54.610 --> 01:47:57.010
irgendwie nervtötend wird ansonsten.

01:47:57.750 --> 01:47:58.070
Und

01:47:58.070 --> 01:48:00.950
wenn man jetzt die ganzen Spezialfunktionen vielleicht

01:48:00.950 --> 01:48:02.990
verwenden will, die halt auch in NumPy und so mit

01:48:02.990 --> 01:48:03.410
drin sind.

01:48:05.090 --> 01:48:06.970
Ja, und genau, dann gehen

01:48:06.970 --> 01:48:08.670
halt die Sachen, die sonst lange dauern, halt

01:48:08.670 --> 01:48:10.050
einfach schnell und

01:48:10.050 --> 01:48:12.210
muss halt ein bisschen anders programmieren.

01:48:12.830 --> 01:48:14.810
Es ist halt dann alles drauf ausgelegt, dass das

01:48:14.810 --> 01:48:16.830
vektorisiert wird und

01:48:16.830 --> 01:48:18.890
das heißt, Vorschleifen und sowas gehen eigentlich

01:48:18.890 --> 01:48:20.910
nicht mehr. Und was natürlich ein bisschen sehr anders

01:48:20.910 --> 01:48:22.090
ist als das, was man normalerweise macht.

01:48:23.130 --> 01:48:24.090
Aber, ja.

01:48:24.690 --> 01:48:26.970
Okay, dafür braucht man dann bei NumPy Arrays

01:48:26.970 --> 01:48:28.190
muss man dann mit Lambda's arbeiten oder

01:48:28.190 --> 01:48:30.830
Ja, oder halt die Funktionen verwenden, die es

01:48:30.830 --> 01:48:32.750
schon gibt. Das meiste gibt es ja, sozusagen

01:48:32.750 --> 01:48:34.850
würde ich mal sagen. Und dann ansonsten, wenn es das halt nicht gibt,

01:48:35.030 --> 01:48:36.270
dann genau, übergibt man halt eine Funktion.

01:48:38.650 --> 01:48:38.970
Okay.

01:48:39.090 --> 01:48:40.770
Wie sehr realisierst du denn dann Daten für

01:48:40.770 --> 01:48:41.630
Übertragungen?

01:48:43.450 --> 01:48:43.770
Ja.

01:48:46.330 --> 01:48:46.950
Kommt drauf an.

01:48:47.510 --> 01:48:48.810
Also erstmal, was das überhaupt zu realisieren ist,

01:48:48.810 --> 01:48:50.870
ist halt in eine Zeichenkette umwandeln,

01:48:50.950 --> 01:48:52.790
dass man das irgendwo hinschicken kann und dass

01:48:52.790 --> 01:48:54.750
wenn man dann weiß, was dahinter steckt, dann man daraus wieder Objekte

01:48:54.750 --> 01:48:56.450
baut, mit denen man Dinge tut.

01:48:56.730 --> 01:48:58.770
Ja, oder genau, ich würde sagen, man hat

01:48:58.770 --> 01:49:00.810
eine Datenstruktur und man möchte sie halt in irgendeine

01:49:00.810 --> 01:49:03.530
Form so verwandeln,

01:49:03.630 --> 01:49:05.390
dass man sie halt irgendwie über Netzwerke schicken kann

01:49:05.390 --> 01:49:07.270
oder irgendwo hinspeichern kann und man

01:49:07.270 --> 01:49:08.370
lädt sie hinterher irgendwo wieder.

01:49:08.470 --> 01:49:10.930
Oder kann auf Papier, dann kann man sie abschreiben.

01:49:11.870 --> 01:49:13.210
Und hat die gleiche Datenstruktur

01:49:13.210 --> 01:49:14.810
wieder irgendwie.

01:49:15.670 --> 01:49:17.270
Und das kann man natürlich, je nachdem

01:49:17.270 --> 01:49:19.070
wie kompliziert das ist, was man halt da

01:49:19.070 --> 01:49:21.350
ein- und

01:49:21.350 --> 01:49:23.450
auspacken möchte, beliebig kompliziert gestalten.

01:49:25.610 --> 01:49:27.230
Also das, was heutzutage ganz

01:49:27.230 --> 01:49:29.110
oft verwendet wird und insofern ist es auch

01:49:29.110 --> 01:49:31.270
keine so schlechte Wahl. JSON wird

01:49:31.270 --> 01:49:32.930
halt oft benutzt.

01:49:33.070 --> 01:49:33.930
Du kannst halt einfach

01:49:33.930 --> 01:49:36.910
nach JSON verwandeln.

01:49:37.070 --> 01:49:38.990
Alles, was irgendwie so Richtung Dikt ist oder verschachtelt

01:49:38.990 --> 01:49:41.330
Dikts. Also meistens

01:49:41.330 --> 01:49:43.210
hast du irgendwie Listen und Dikts

01:49:43.210 --> 01:49:45.390
irgendwie ineinander verschachtelt sozusagen als Datensstruktur.

01:49:45.750 --> 01:49:47.370
Das kannst du halt hervorragend irgendwie als JSON

01:49:47.370 --> 01:49:49.070
einfach realisieren. Also auch mit Frequenzmentation

01:49:49.070 --> 01:49:50.750
kein Problem, auch mit Tucheln kein Problem.

01:49:51.930 --> 01:49:52.950
Daten, also

01:49:52.950 --> 01:49:55.410
Datums. Genau, das ist

01:49:55.410 --> 01:49:57.110
Datumsformate. Das ist halt

01:49:57.110 --> 01:49:59.070
halt blöd. Genau, solche Sachen gehen dann schon nicht mehr

01:49:59.070 --> 01:50:00.590
so gut. Also wenn du jetzt

01:50:00.590 --> 01:50:02.590
ein Datum hast, dass du irgendwie oder

01:50:02.590 --> 01:50:04.890
einen Zeitpunkt, wenn du den

01:50:04.890 --> 01:50:05.630
irgendwie in JSON

01:50:05.630 --> 01:50:08.130
speichern willst, dann ist es halt blöd.

01:50:08.370 --> 01:50:10.810
Also der Flur von Datum ist Daten. Das ist aber gerade

01:50:10.810 --> 01:50:12.790
ein bisschen verwirrend, wenn wir über Daten schon so reden.

01:50:13.290 --> 01:50:14.770
Aber ja. Ja, genau.

01:50:14.870 --> 01:50:16.130
Das ist ein bisschen kacke.

01:50:17.610 --> 01:50:18.710
Und dann gibt es natürlich dann

01:50:18.710 --> 01:50:20.570
diverse ISO-Standards, wie man das dann doch

01:50:20.570 --> 01:50:22.710
irgendwie mit Zeitzone und keine Ahnung

01:50:22.710 --> 01:50:24.470
und dann bist du aber darauf angewiesen, dass alle irgendwie

01:50:24.470 --> 01:50:26.730
die gleiche Idee davon haben, was denn jetzt in diesem

01:50:26.730 --> 01:50:28.870
String, der da in dem JSON

01:50:28.870 --> 01:50:30.390
steht, was das

01:50:30.390 --> 01:50:32.830
jetzt gemeint ist. Und das ist manchmal ein bisschen

01:50:32.830 --> 01:50:33.970
nervtötend.

01:50:35.570 --> 01:50:35.590
Aber

01:50:35.590 --> 01:50:38.770
solange man nicht, also Datum ist immer etwas, was

01:50:38.770 --> 01:50:40.750
meistens dann Probleme macht, aber einfach

01:50:40.750 --> 01:50:41.630
so Listen,

01:50:42.910 --> 01:50:44.490
Dicts, Strings,

01:50:44.690 --> 01:50:45.550
das funktioniert ganz gut.

01:50:46.590 --> 01:50:48.550
Und ja, also für diese

01:50:48.550 --> 01:50:50.530
einfachen Fälle ist JSON

01:50:50.530 --> 01:50:51.230
ganz gut geeignet.

01:50:52.230 --> 01:50:54.690
Da da auch mittlerweile so viel verwendet wird, ist da auch viel Arbeit

01:50:54.690 --> 01:50:56.430
reingeflossen, die Parser und

01:50:56.430 --> 01:51:00.650
Rausschreibdinger

01:51:00.650 --> 01:51:02.410
halt schnell zu machen und das geht eigentlich

01:51:02.410 --> 01:51:02.970
alles ziemlich gut.

01:51:04.630 --> 01:51:06.630
Es ist halt auch halbwegs sparsam,

01:51:06.770 --> 01:51:08.130
was halt sozusagen den Platz angeht.

01:51:08.510 --> 01:51:10.150
Wenn du jetzt eben sowas wie XML nimmst,

01:51:10.190 --> 01:51:12.410
XML ist halt da, kannst du mehr mitmachen,

01:51:12.690 --> 01:51:14.170
aber es ist halt komplizierter,

01:51:14.330 --> 01:51:15.790
viele Dinge sind da schon gedacht worden,

01:51:16.330 --> 01:51:17.770
aber das ist halt einfach,

01:51:17.930 --> 01:51:19.910
es wird oft riesig.

01:51:21.050 --> 01:51:22.230
Was heißt mehr kann man damit machen?

01:51:22.590 --> 01:51:23.850
Warum? Ja, da kannst du halt,

01:51:24.090 --> 01:51:26.370
du kannst da ja ein Format dann definieren,

01:51:26.430 --> 01:51:28.330
Du kannst ja halt irgendwie auch

01:51:28.330 --> 01:51:29.830
definieren, wie die Daten aussehen.

01:51:30.210 --> 01:51:32.210
Du kannst beschreiben, wie das, was du

01:51:32.210 --> 01:51:34.010
reinschreibst, wann das

01:51:34.010 --> 01:51:35.650
okay ist. Du kannst halt eine DTD

01:51:35.650 --> 01:51:37.970
Data, wie heißt das?

01:51:38.090 --> 01:51:39.910
Data Type Definition zu deinem

01:51:39.910 --> 01:51:42.030
XML dazuschreiben, das halt sozusagen

01:51:42.030 --> 01:51:44.010
definiert, wie das Format von deinem

01:51:44.010 --> 01:51:46.170
XML aussieht. Und dann kannst du das validieren

01:51:46.170 --> 01:51:46.870
dagegen und so.

01:51:48.090 --> 01:51:48.270
Ja.

01:51:52.710 --> 01:51:54.010
Ein heimlicher

01:51:54.010 --> 01:51:54.990
XML-Fan? Nein.

01:51:56.430 --> 01:51:59.290
Nein, das ist alles sehr

01:51:59.290 --> 01:52:01.330
schrecklich. Also ich meine, man kann

01:52:01.330 --> 01:52:03.470
das machen, aber das ist alles...

01:52:03.470 --> 01:52:05.510
Nee, es gibt auch einen Grund, warum das quasi

01:52:05.510 --> 01:52:07.350
niemand... also niemand

01:52:07.350 --> 01:52:07.670
tut.

01:52:10.050 --> 01:52:10.950
Das ist...

01:52:10.950 --> 01:52:12.950
Ja, also

01:52:12.950 --> 01:52:15.550
in der Anfangszeit war das...

01:52:15.550 --> 01:52:17.350
Also mittlerweile ist das auch alles nicht mehr so

01:52:17.350 --> 01:52:19.350
schlimm. Es gibt gute Bibliotheken, aber

01:52:19.350 --> 01:52:23.290
es war schon nicht so einfach

01:52:23.290 --> 01:52:25.350
manchmal. Und was halt an XML nervtötend

01:52:25.350 --> 01:52:26.950
ist es halt, du kannst es als Mensch nicht gut lesen,

01:52:27.350 --> 01:52:28.850
es ist halt gigantisch groß.

01:52:30.070 --> 01:52:31.070
Hässlich. Hässlich,

01:52:31.270 --> 01:52:31.550
ja.

01:52:35.550 --> 01:52:37.070
Ja, und

01:52:37.070 --> 01:52:39.010
dann gibt es natürlich noch sowas wie Jammel oder so,

01:52:39.150 --> 01:52:41.010
heute irgendwie so ein bisschen auch wieder

01:52:41.010 --> 01:52:43.270
en vogue. Auch hässlich.

01:52:43.390 --> 01:52:45.290
Ist aber auch, ja, ist auch ein bisschen hässlich,

01:52:45.390 --> 01:52:46.270
muss man leider sagen, ja.

01:52:48.070 --> 01:52:49.070
Wie hat das dann jemand

01:52:49.070 --> 01:52:50.790
formuliert, ne, so irgendwie Jammel,

01:52:50.790 --> 01:52:52.650
das, was dabei rauskommt,

01:52:52.730 --> 01:52:54.890
wenn man irgendwie alle Fehler ignoriert,

01:52:54.950 --> 01:52:56.410
die bei JSON gemacht worden sind.

01:52:56.490 --> 01:52:57.730
Und JSON ist das, was rauskommt,

01:52:57.790 --> 01:53:00.410
wenn alle viele kreative XML gemacht worden sind.

01:53:01.070 --> 01:53:03.850
Und die Geschichte wiederholt sich immer und immer wieder.

01:53:04.830 --> 01:53:05.810
Irgendwie das nächste Format heißt,

01:53:05.870 --> 01:53:06.570
was man nicht gebrauchen kann.

01:53:06.850 --> 01:53:08.110
Genau, das ist halt echt so ein,

01:53:08.210 --> 01:53:09.510
aber XML ist auch so ein bisschen,

01:53:10.130 --> 01:53:11.850
das wurde früher immer gespottet,

01:53:11.950 --> 01:53:13.150
dass man dem Format ansieht,

01:53:13.210 --> 01:53:14.170
dass es irgendwie von Juristen

01:53:14.170 --> 01:53:16.090
und nicht von Informatikern konzipiert wurde.

01:53:16.610 --> 01:53:18.350
Und dass man irgendwie solche Sachen nicht hat,

01:53:18.350 --> 01:53:20.810
wie, also, du kannst es nicht ordentlich quoten.

01:53:22.210 --> 01:53:22.970
Wenn du jetzt zum Beispiel,

01:53:23.050 --> 01:53:25.570
innerhalb von XML gibt es halt so was

01:53:25.570 --> 01:53:27.690
wie Kommentare. Wie willst du XML-Kommentare

01:53:27.690 --> 01:53:28.990
quoten? Das geht überhaupt gar nicht.

01:53:29.630 --> 01:53:30.670
Und das heißt, wenn du jetzt zum Beispiel

01:53:30.670 --> 01:53:33.370
in einem XML-Dokument

01:53:33.370 --> 01:53:35.570
beschreiben willst, wie denn jetzt XML auszusehen

01:53:35.570 --> 01:53:36.830
hat mit XML-Kommentaren,

01:53:37.890 --> 01:53:39.450
da passieren ganz schreckliche Sachen. Das geht alles überhaupt

01:53:39.450 --> 01:53:41.170
gar nicht. Und das ist halt so.

01:53:41.670 --> 01:53:43.210
Es kann auch nicht sein, dass daran keiner gedacht hat,

01:53:43.310 --> 01:53:44.650
dass das jetzt nicht geht. Das geht einfach nicht.

01:53:45.210 --> 01:53:47.970
Und ja, es ist nicht so,

01:53:48.030 --> 01:53:49.270
dass man sich sagt, das ist voll super elegant,

01:53:49.270 --> 01:53:50.790
total gut, nehmen wir jetzt sofort.

01:53:51.230 --> 01:53:52.510
Sondern es ist mehr so, oh,

01:53:52.730 --> 01:53:53.490
oh, schrecklich.

01:53:54.710 --> 01:53:56.810
Und JSON ist aus dieser Perspektive

01:53:56.810 --> 01:53:58.750
für mich weniger schrecklich. Also es ist halt,

01:53:58.790 --> 01:54:00.530
es kann deutlich weniger, aber

01:54:00.530 --> 01:54:02.770
okay, dafür ist es halt alles

01:54:02.770 --> 01:54:04.790
nicht so schlimm. Ist ja zum Serialisieren da, also dass man

01:54:04.790 --> 01:54:06.690
Daten irgendwo hinlegt als Pfeil

01:54:06.690 --> 01:54:08.710
oder sowas. Aber es gibt natürlich dann gewisse

01:54:08.710 --> 01:54:10.770
Begrenzungen, was halt dann nicht gut

01:54:10.770 --> 01:54:12.750
funktioniert. Eben, ja, Datum oder

01:54:12.750 --> 01:54:14.670
alles, was irgendwie komplizierte Objekte sind und Code

01:54:14.670 --> 01:54:15.850
kannst du da auch nicht mit reinpacken.

01:54:16.930 --> 01:54:17.690
Das geht alles nicht.

01:54:18.590 --> 01:54:20.610
Und auch dann für die Übertragung

01:54:20.610 --> 01:54:22.510
im Netz ist halt auch teilweise nicht so gut,

01:54:22.590 --> 01:54:24.550
weil das halt dann Text ist und

01:54:24.550 --> 01:54:26.930
das hat also bestimmte schlechte Eigenschaften.

01:54:27.830 --> 01:54:28.690
Du möchtest eigentlich,

01:54:29.030 --> 01:54:30.410
naja, da gibt es dann sowas, da gibt es dann ein etwas

01:54:30.410 --> 01:54:32.190
besseres Format, Message Pack nennt sich das,

01:54:32.270 --> 01:54:34.750
das kann man halt, das ist so ähnlich wie JSON, bloß

01:54:34.750 --> 01:54:36.530
binär so,

01:54:36.710 --> 01:54:38.290
dass das halt irgendwie

01:54:38.290 --> 01:54:40.410
nicht kaputt gehen kann bei der Übertragung

01:54:40.410 --> 01:54:41.910
oder nicht so leicht kaputt gehen kann wie JSON.

01:54:43.090 --> 01:54:43.350
Ja,

01:54:43.710 --> 01:54:45.870
und, naja,

01:54:46.570 --> 01:54:48.390
aber JSON ist eigentlich schon, würde ich sagen,

01:54:48.430 --> 01:54:50.250
für viele Fälle so das, was man eigentlich

01:54:50.250 --> 01:54:51.850
haben will. Und

01:54:51.850 --> 01:54:53.910
wenn es dann noch viel komplizierter wird, kann man auch

01:54:53.910 --> 01:54:55.270
sowas nehmen wie Pickle, da muss man aufpassen.

01:54:56.570 --> 01:54:57.110
Ja, es gibt noch

01:54:57.110 --> 01:55:00.030
in Python selber,

01:55:00.130 --> 01:55:01.790
wenn ich jetzt überlege, gibt es noch eingebaute

01:55:01.790 --> 01:55:03.790
Geschichten. Es gibt noch Marshall, das Modul, das macht sowas

01:55:03.790 --> 01:55:05.650
ähnliches wie JSON,

01:55:05.830 --> 01:55:07.850
bloß halt binär. Das ist auch noch ein Stückchen

01:55:07.850 --> 01:55:09.890
schneller. Und dann gibt es noch

01:55:09.890 --> 01:55:11.690
Shelf, glaube ich. Das weiß ich aber nicht.

01:55:11.750 --> 01:55:13.130
Das habe ich schon ganz lange nicht mehr verwendet.

01:55:14.570 --> 01:55:15.770
Und eben, wenn man jetzt

01:55:15.770 --> 01:55:17.350
aber nicht nur Daten

01:55:17.350 --> 01:55:19.910
serialisieren will, sondern vielleicht

01:55:19.910 --> 01:55:21.730
auch Code mit, also komplette Objekte

01:55:21.730 --> 01:55:22.690
mit Funktionalität,

01:55:23.970 --> 01:55:25.930
dann sowas wie Pickle.

01:55:26.230 --> 01:55:27.870
Und Pickle kann man auch schicken als Binär-File,

01:55:27.950 --> 01:55:29.490
dann über das Netz. Genau, man kann

01:55:29.490 --> 01:55:31.890
verwandelt halt ein komplettes Objekt

01:55:31.890 --> 01:55:33.790
zum Beispiel in einen binären String

01:55:33.790 --> 01:55:35.590
und dann schickt man den irgendwie über das Netz.

01:55:35.690 --> 01:55:37.790
Auf der anderen Seite deserialisiert man den

01:55:37.790 --> 01:55:39.190
und dann hat man dieses Objekt wieder da.

01:55:40.210 --> 01:55:41.050
Das ist natürlich sehr praktisch.

01:55:41.550 --> 01:55:43.730
Was ein bisschen schlecht dran ist, ist, man muss halt sehr aufpassen,

01:55:44.910 --> 01:55:45.990
dass man dann führt der Code aus.

01:55:46.210 --> 01:55:46.610
Also wenn

01:55:46.610 --> 01:55:49.590
einem jemand irgendwie, der nicht

01:55:49.590 --> 01:55:50.430
vertrauenswürdig ist,

01:55:51.390 --> 01:55:52.750
irgendwas Gepickeltes schickt,

01:55:53.330 --> 01:55:55.590
da kann ein beliebiger Code drin sein.

01:55:55.830 --> 01:55:57.370
Also wenn man das anpickelt,

01:55:57.530 --> 01:55:58.910
dann führt man das aus, was da drin steht.

01:55:59.870 --> 01:56:00.170
Das heißt,

01:56:00.570 --> 01:56:03.570
das sollte man sich klar machen.

01:56:03.970 --> 01:56:04.610
Hier ist eine Bombe.

01:56:05.310 --> 01:56:05.630
Genau.

01:56:06.630 --> 01:56:08.470
Also irgendwas

01:56:08.470 --> 01:56:11.710
anpickeln, was einem jemand

01:56:11.710 --> 01:56:13.370
gibt, ist so wie Code ausführen,

01:56:13.370 --> 01:56:14.090
wenn es jemand gibt.

01:56:14.390 --> 01:56:16.430
Wenn ich ein Paket öffne, was man nach Hause geschickt bekommen hat,

01:56:16.470 --> 01:56:17.910
da kann auch eine Briefbombe drin sein.

01:56:18.070 --> 01:56:20.990
Das ist immer auch beim Essen,

01:56:21.030 --> 01:56:22.750
Wenn man isst, was man nicht kennt, dann immer Vorkost

01:56:22.750 --> 01:56:23.170
da daneben.

01:56:25.930 --> 01:56:26.250
Ja.

01:56:27.530 --> 01:56:28.410
Man weiß nicht so genau.

01:56:28.690 --> 01:56:30.970
Die Paranoia kann ja beliebig weit getrieben werden.

01:56:31.350 --> 01:56:32.130
Genau, genau, genau.

01:56:32.850 --> 01:56:34.750
Pickel, lass mal überlegen. Es gibt da noch

01:56:34.750 --> 01:56:36.690
diverse, es gibt da noch für den

01:56:36.690 --> 01:56:38.510
wissenschaftlichen Bereich ein paar Sachen. Es gibt noch

01:56:38.510 --> 01:56:39.210
HDF 5,

01:56:40.190 --> 01:56:42.590
Net, wie heißt das Ding, Net CD.

01:56:44.410 --> 01:56:44.870
Ich hab's

01:56:44.870 --> 01:56:45.390
jetzt wieder vergessen.

01:56:47.590 --> 01:56:48.450
Wie der Standard ist.

01:56:49.370 --> 01:56:50.910
Es gibt so eben für wissenschaftliche

01:56:50.910 --> 01:56:52.690
Daten, da gibt es noch Standards,

01:56:52.910 --> 01:56:55.070
wie man Sachen speichert,

01:56:55.110 --> 01:56:56.370
die noch so ein bisschen anders sind.

01:56:58.170 --> 01:56:59.230
Eine CDF, glaube ich,

01:56:59.270 --> 01:57:01.110
ist das. Ja, so ein HDF5

01:57:01.110 --> 01:57:03.010
ist einer der, das gehört

01:57:03.010 --> 01:57:04.370
da irgendwie mit rein in diese Reihenfolge.

01:57:04.410 --> 01:57:05.710
Ja, hört sich irgendwie total kaputt an.

01:57:06.510 --> 01:57:07.770
Ja, und

01:57:07.770 --> 01:57:10.790
NumPy-Arrays haben auch noch mal eine eigene

01:57:10.790 --> 01:57:12.470
Möglichkeit, wie man sie serialisieren kann.

01:57:13.070 --> 01:57:14.130
Man kann die auch Memory mappen.

01:57:16.930 --> 01:57:18.870
Ja, oder ich meine, CSV ist auch eine Möglichkeit,

01:57:18.870 --> 01:57:20.890
Sachen zu serialisieren. CSV ist auch wieder so ein Format,

01:57:20.910 --> 01:57:23.410
so eigene, fürchterliche,

01:57:23.510 --> 01:57:24.630
schreckliche Sachen mit sich bringt.

01:57:26.010 --> 01:57:26.290
Aber

01:57:26.290 --> 01:57:29.530
also in anderer Sicht

01:57:29.530 --> 01:57:31.150
ist es auch wieder ganz gut. Also oft

01:57:31.150 --> 01:57:33.470
würde ich sagen, wenn man

01:57:33.470 --> 01:57:35.270
die Wahl hat zwischen CSV und XML, ist CSV

01:57:35.270 --> 01:57:36.110
die bessere Wahl.

01:57:37.190 --> 01:57:38.570
Aber ja.

01:57:40.890 --> 01:57:41.290
Tja.

01:57:42.310 --> 01:57:42.850
Ja, aber das

01:57:42.850 --> 01:57:45.150
war es im Grunde eigentlich. Haben wir noch

01:57:45.150 --> 01:57:46.530
eine wichtige Serialisierungsgeschichte?

01:57:46.850 --> 01:57:49.290
Ja, ich glaube, wir wollen ja auch, eigentlich wollen wir ja nur eine Minute

01:57:49.290 --> 01:57:50.370
reden. Ich glaube, das halten wir jetzt.

01:57:50.650 --> 01:57:51.430
Ui, ui, ui, ui.

01:57:52.190 --> 01:57:54.930
Ja, ich habe jetzt noch so ein paar Themen, die sind irgendwie jetzt alle aber sehr unzusammenhängend

01:57:54.930 --> 01:57:56.630
auch. Ich überlege gerade,

01:57:56.770 --> 01:57:58.370
wo ich damit jetzt noch anfangen soll. Ich glaube,

01:57:58.450 --> 01:58:00.590
Memory Management hatten wir schon mal gesprochen. Ich glaube, in einer der ersten

01:58:00.590 --> 01:58:02.490
Folgen haben wir ja über den JIT und den GIL gesprochen.

01:58:02.750 --> 01:58:05.030
An den Just-in-Time-Compiler

01:58:05.030 --> 01:58:06.510
und an den Global Interpreter-Log.

01:58:07.890 --> 01:58:08.610
Dann habe ich

01:58:08.610 --> 01:58:10.510
jetzt noch das Konzept von MapReduce, aber ich weiß

01:58:10.510 --> 01:58:12.370
nicht, ob das jetzt hier zugehört, dass das irgendwie

01:58:12.370 --> 01:58:14.410
nicht ganz da reinpasst. Nee, ich glaube, es ist auch so ein bisschen veraltet.

01:58:14.750 --> 01:58:15.990
Also inzwischen macht das keiner mehr.

01:58:16.590 --> 01:58:18.410
Und dann, was mich aber natürlich noch

01:58:18.410 --> 01:58:20.350
interessiert, wenn man halt debuggen möchte, was da irgendwie

01:58:20.350 --> 01:58:22.510
der Zeug ist, dann gibt es irgendwie so ein bisschen

01:58:22.510 --> 01:58:24.090
so, ich nenne es jetzt mal Deep Debugging.

01:58:24.230 --> 01:58:26.570
Das heißt, man kann Deer auf irgendwelche

01:58:26.570 --> 01:58:28.330
Fehler spawnen oder Help aufrufen

01:58:28.330 --> 01:58:30.230
und so. Was gibt es denn da noch? Und wie würde man

01:58:30.230 --> 01:58:32.170
sich dann angucken, was überhaupt möglich ist

01:58:32.170 --> 01:58:34.590
mit so Objekten, die man da zurückbekommt,

01:58:34.670 --> 01:58:36.190
wo man nicht genau weiß, woran liegt denn das jetzt?

01:58:36.730 --> 01:58:37.870
Guckt man denn da genauer rein?

01:58:37.910 --> 01:58:40.350
Naja, ich glaube, das ist schon, also Help zeigt halt den

01:58:40.350 --> 01:58:41.930
Also macht man Help, das ist eine Funktion,

01:58:42.050 --> 01:58:44.210
die man außen rum schmeißt und was, was zurückkommt?

01:58:45.410 --> 01:58:46.110
Ja, aber das

01:58:46.110 --> 01:58:48.330
also an den Objekten hängen halt

01:58:48.330 --> 01:58:50.230
auch immer Dinge dran, also zum Beispiel man an den

01:58:50.230 --> 01:58:52.390
Funktionsobjekt hängt da halt auch mal die Dokumentation,

01:58:52.390 --> 01:58:54.350
also der Dockstring hängt da halt mit dran, den man sich dann

01:58:54.350 --> 01:58:56.350
angucken kann. Und ich weiß nicht genau, was Help macht, aber

01:58:56.350 --> 01:58:58.410
Help, glaube ich, wird sowas tun, wie

01:58:58.410 --> 01:59:00.510
die Dockstrings nehmen und anzeigen,

01:59:00.930 --> 01:59:01.370
mehr oder weniger.

01:59:03.030 --> 01:59:04.370
Und dir zeigt

01:59:04.370 --> 01:59:06.650
halt alle Attribute und Methoden

01:59:06.650 --> 01:59:07.750
oder so an einem Objekt,

01:59:08.290 --> 01:59:09.830
die da so dranhängen.

01:59:10.610 --> 01:59:11.630
Und dann, ja,

01:59:12.790 --> 01:59:14.470
also zumindest kann man sich dann,

01:59:14.550 --> 01:59:16.390
zeigt es auch die Funktion Signature, glaube ich, an

01:59:16.390 --> 01:59:18.390
noch. Was gibt es denn noch?

01:59:19.270 --> 01:59:21.090
Nee, mehr verwende ich eigentlich auch

01:59:21.090 --> 01:59:22.050
praktisch nicht.

01:59:23.710 --> 01:59:25.470
Dieses MRO, dieses Basis,

01:59:25.570 --> 01:59:27.330
also wenn man so eine von diesen Objekten, die man mit dir

01:59:27.330 --> 01:59:29.290
dann rausbekommt, sich anguckt, dann

01:59:29.290 --> 01:59:31.370
bekommt man natürlich noch viel mehr Informationen, weil diese ganzen

01:59:31.370 --> 01:59:33.470
Magic Methods, so Meta-Attribute

01:59:33.470 --> 01:59:35.390
irgendwie von den Klassen dranhängen, dass man

01:59:35.390 --> 01:59:37.190
zum Beispiel jetzt mit Basis sehen kann,

01:59:37.290 --> 01:59:39.170
welche Oberklassen hat denn überhaupt

01:59:39.170 --> 01:59:40.870
das Ding, wo ich dann drin bin. Ah, okay, cool.

01:59:40.990 --> 01:59:42.030
Nee, hab ich noch nie verwendet, glaube ich.

01:59:42.530 --> 01:59:44.490
So kann man halt noch ein bisschen tiefer reingucken in dieses

01:59:44.490 --> 01:59:46.590
Vererbungshierarchie-Ding und dieses

01:59:46.590 --> 01:59:48.910
MRO, also diese Method Resolution Order, zeigt dann

01:59:48.910 --> 01:59:50.850
dann vielleicht genau, welches von den

01:59:50.850 --> 01:59:52.910
Dingen aufgerufen worden ist,

01:59:52.910 --> 01:59:54.950
von den Methoden, die man jetzt in reiner

01:59:54.950 --> 01:59:57.030
Weise überschrieben hat und was da eigentlich hintersteckt,

01:59:57.110 --> 01:59:58.830
damit man vielleicht weiß, oh, es wurde etwas Falsches

01:59:58.830 --> 02:00:00.510
aufgerufen. Also so kann man so ein bisschen immer gucken,

02:00:00.930 --> 02:00:02.830
wenn irgendwas schief geht, wo man überhaupt nicht weiß, was man

02:00:02.830 --> 02:00:04.630
da gemacht hat, dass man nicht mehr irgendeinen Komma vergessen hat,

02:00:05.550 --> 02:00:06.370
wie man dann da reinkommt.

02:00:06.490 --> 02:00:07.790
Wobei da dann vielleicht auch

02:00:07.790 --> 02:00:10.290
eine bessere Wahl wäre, einfach direkt

02:00:10.290 --> 02:00:13.030
einen T-Bugger zu verwenden.

02:00:13.730 --> 02:00:15.150
Ja, welchen würdest du da empfehlen?

02:00:15.290 --> 02:00:16.710
Ja, PDB ist halt so das, was

02:00:16.710 --> 02:00:18.030
und man kann ja auch inzwischen...

02:00:18.030 --> 02:00:19.790
was macht PDB? Also der stoppt den Code

02:00:19.790 --> 02:00:21.930
zur Ausführzeiten, man hat eine Shell und kann dann

02:00:21.930 --> 02:00:22.050
da hochgehen.

02:00:22.050 --> 02:00:23.550
Du kannst halt auch irgendwie, genau,

02:00:24.530 --> 02:00:25.470
im Code halt rein

02:00:25.470 --> 02:00:26.690
Set Trace,

02:00:26.950 --> 02:00:30.630
da muss ich mal nachgucken,

02:00:31.130 --> 02:00:32.130
schreibst halt einfach deinen Code rein

02:00:32.130 --> 02:00:33.370
und dann hast du da halt

02:00:33.370 --> 02:00:35.230
ein, stoppt halt

02:00:35.230 --> 02:00:37.050
die Ausführungen an der Stelle

02:00:37.050 --> 02:00:39.250
und du kriegst halt ein interaktives Prompt,

02:00:39.290 --> 02:00:41.290
an dem du halt gucken kannst, was steht denn zum Beispiel in den Variablen

02:00:41.290 --> 02:00:43.250
drin und dann kannst du halt auch

02:00:43.250 --> 02:00:45.210
sagen, okay, ich gehe jetzt hier weiter oder ich überspringe

02:00:45.210 --> 02:00:47.490
das und gucke dann wieder, was ist denn da los

02:00:47.490 --> 02:00:49.570
und genau, also

02:00:49.570 --> 02:00:51.190
und dann weißt du ja genau, wo du bist.

02:00:53.290 --> 02:00:53.650
Also

02:00:53.650 --> 02:00:55.470
das ist eine schöne Geschichte, ich weiß jetzt nicht,

02:00:55.570 --> 02:00:56.810
seit wann das

02:00:56.810 --> 02:00:59.330
Tracing eingebaut ist, das müsste jetzt auch irgendwann,

02:00:59.550 --> 02:01:01.010
das ist noch nicht so lange her, glaube ich.

02:01:01.750 --> 02:01:02.370
Ja, aber

02:01:02.370 --> 02:01:05.490
Debugger hilft einem da schon

02:01:05.490 --> 02:01:07.170
deutlich, ja.

02:01:07.890 --> 02:01:09.570
Funktioniert halt auch in Django oder

02:01:09.570 --> 02:01:11.590
so, kriegt man das über

02:01:11.590 --> 02:01:13.330
die Webseite halt dann entsprechend schnell.

02:01:13.430 --> 02:01:15.410
Ich glaube, das gehört auch mit der VSCode, also der Enito, der hat das

02:01:15.410 --> 02:01:17.090
irgendwie auch implementiert. Ja, das muss ich mir auch nochmal angucken,

02:01:17.290 --> 02:01:18.990
auch noch gar nicht richtig genutzt.

02:01:19.150 --> 02:01:20.910
Man kann halt dann so Debug-Stops

02:01:20.910 --> 02:01:21.630
setzen und so.

02:01:22.690 --> 02:01:23.910
Ja, Breakpoints.

02:01:24.130 --> 02:01:24.870
Introspection, ja genau.

02:01:26.590 --> 02:01:27.810
Ja, ich habe jetzt noch

02:01:27.810 --> 02:01:29.490
zwei andere wieder. Punkt drauf, die haben nichts mehr zu tun.

02:01:29.570 --> 02:01:31.590
Zwar einmal, wie löst man Multithreading in Python?

02:01:32.750 --> 02:01:33.250
Ja, das

02:01:33.250 --> 02:01:35.690
funktioniert so wie sonst auch.

02:01:36.130 --> 02:01:37.530
Also tatsächlich sind auch Threads in

02:01:37.530 --> 02:01:39.190
Python halt tatsächlich ganz normale,

02:01:39.430 --> 02:01:41.470
bilden sich ab auf Threads im

02:01:41.470 --> 02:01:41.970
Betriebssystem.

02:01:44.530 --> 02:01:45.750
Es ist halt nur so, dass

02:01:45.750 --> 02:01:48.290
die nicht wirklich parallel

02:01:48.290 --> 02:01:49.270
Dinge tun können

02:01:49.270 --> 02:01:52.090
auf unterschiedlichen CPUs sozusagen. Sie können schon

02:01:52.090 --> 02:01:54.090
parallel Sachen machen, aber halt natürlich dann

02:01:54.090 --> 02:01:55.690
nicht so wirklich, weil

02:01:55.690 --> 02:01:57.890
nicht gleichzeitig,

02:01:58.470 --> 02:02:00.090
weil Sachen auf einer CPU

02:02:00.090 --> 02:02:01.830
natürlich doch dann irgendwie immer sequenziell

02:02:01.830 --> 02:02:03.350
abgearbeitet werden, aber

02:02:03.350 --> 02:02:09.890
man benutzt die aber,

02:02:10.430 --> 02:02:12.070
also daher kann man sie nicht dafür

02:02:12.070 --> 02:02:13.390
verwenden, um

02:02:13.390 --> 02:02:16.050
Berechnungen zu parallelisieren,

02:02:16.130 --> 02:02:17.810
weil eben dafür müsste man es ja auf Prozessoren

02:02:17.810 --> 02:02:19.510
aufteilen können. Das geht nicht.

02:02:20.310 --> 02:02:21.950
Aber um

02:02:21.950 --> 02:02:23.170
I.O. zu multiplexen,

02:02:23.730 --> 02:02:25.710
geht das ganz hervorragend und das

02:02:25.710 --> 02:02:27.810
funktioniert gut, kann man

02:02:27.810 --> 02:02:28.470
dafür benutzen.

02:02:29.810 --> 02:02:31.270
Ist jetzt nicht so die

02:02:31.270 --> 02:02:33.690
moderne Art,

02:02:33.770 --> 02:02:34.290
das zu tun.

02:02:35.630 --> 02:02:37.510
Da würde man wahrscheinlich eher sowas wie Async.io

02:02:37.510 --> 02:02:39.430
nehmen oder so. Aber

02:02:39.430 --> 02:02:41.090
man kann auch FETs benutzen,

02:02:41.270 --> 02:02:42.570
ist völlig okay.

02:02:43.170 --> 02:02:45.470
Also Async.io macht dann echt das Multithreading auf Multiprozessor?

02:02:45.490 --> 02:02:46.470
Nee, das macht kein Threading.

02:02:46.870 --> 02:02:48.230
Async.io ist wieder eine andere Geschichte.

02:02:48.450 --> 02:02:48.750
Was ist das?

02:02:49.290 --> 02:02:54.190
Async.io ist, ja, kann man sagen, einmal eine Event-Loop,

02:02:54.870 --> 02:02:57.070
sozusagen so ähnlich wie in Node.js oder so auch,

02:02:58.210 --> 02:03:00.530
wo halt immer geguckt wird, was gibt es denn jetzt gerade zu tun oder so,

02:03:00.530 --> 02:03:01.950
und dann macht man halt an einer bestimmten Stelle weiter.

02:03:02.710 --> 02:03:05.210
Aber vor allen Dingen halt auch eine Syntax,

02:03:05.350 --> 02:03:10.270
wie man das so hinschreibt, dass das automatisch gehandelt werden kann.

02:03:10.530 --> 02:03:11.990
Also ich kann halt sozusagen

02:03:11.990 --> 02:03:14.350
in Python Funktionen als async

02:03:14.350 --> 02:03:16.430
deklarieren und dann

02:03:16.430 --> 02:03:18.830
kann ich halt die Ausführungen,

02:03:19.250 --> 02:03:20.310
wenn die zum Beispiel blockieren, halt

02:03:20.310 --> 02:03:22.310
unterbrechen. Die werden dann später weiter ausgeführt, wenn es

02:03:22.310 --> 02:03:23.190
halt wieder was zu tun gibt.

02:03:24.770 --> 02:03:26.290
Und ja,

02:03:27.750 --> 02:03:28.950
das,

02:03:30.490 --> 02:03:32.210
aber das müssten wir, wenn man das wirklich erklären

02:03:32.210 --> 02:03:33.990
will, wie das funktioniert, müssen wir noch mal eine Folge

02:03:33.990 --> 02:03:34.350
zu machen.

02:03:36.270 --> 02:03:38.370
Eben, damit kann man halt auch IOMultiplexen

02:03:38.370 --> 02:03:40.050
und das

02:03:40.050 --> 02:03:42.210
Ganze in einer etwas intuitiveren

02:03:42.210 --> 02:03:43.970
Art hinschreiben, als wenn man das jetzt mit

02:03:43.970 --> 02:03:45.570
Threading machen würde. Weil wenn man das mit Threading

02:03:45.570 --> 02:03:47.910
mit dem Threading-Modul macht, dann

02:03:47.910 --> 02:03:49.270
wird es sehr schnell auch sehr

02:03:49.270 --> 02:03:51.910
unintuitiv. Und was man auch

02:03:51.910 --> 02:03:54.050
irgendwie dabei beachten muss,

02:03:54.110 --> 02:03:55.030
ist halt, wenn man

02:03:55.030 --> 02:03:57.870
Tracebacks kriegt irgendwo

02:03:57.870 --> 02:04:00.110
in Workern, die halt in unterschiedlichen

02:04:00.110 --> 02:04:01.730
Threads laufen, das kann sehr

02:04:01.730 --> 02:04:02.850
und also man,

02:04:03.490 --> 02:04:05.750
das ist halt sowieso das Problem, wenn man jetzt irgendwie Dinge

02:04:05.750 --> 02:04:07.690
asynchron tut oder so, die halt so

02:04:07.690 --> 02:04:08.070
irgendwie,

02:04:09.350 --> 02:04:10.790
Man hat nicht mehr so wirklich

02:04:10.790 --> 02:04:13.010
einen linearen, der Code läuft

02:04:13.010 --> 02:04:14.910
nicht mehr so linear durch, sondern man weiß

02:04:14.910 --> 02:04:16.850
halt nie so genau, wo man gerade ist und was da gerade

02:04:16.850 --> 02:04:18.950
passiert. Und wenn man da Tracebacks kriegt

02:04:18.950 --> 02:04:20.870
und viele Threads verwendet

02:04:20.870 --> 02:04:22.990
und dann weiß man manchmal echt

02:04:22.990 --> 02:04:24.430
gar nicht, was da gerade passiert ist.

02:04:24.830 --> 02:04:26.890
Manchmal kommt man in Zuständen raus, die sehr eigenartig sind

02:04:26.890 --> 02:04:28.710
und das ist dann immer sehr hässlich zu debuggen.

02:04:29.470 --> 02:04:31.210
Und das geht mit AsyncIO

02:04:31.210 --> 02:04:32.810
deutlich besser. Also es ist halt

02:04:32.810 --> 02:04:34.890
deutlich eher so, dass man

02:04:34.890 --> 02:04:36.970
Code so hinschreibt, als wäre

02:04:36.970 --> 02:04:38.750
er synchron quasi, aber

02:04:38.750 --> 02:04:40.750
er dann halt automatisch mehr oder weniger

02:04:40.750 --> 02:04:42.810
Async, also so ist das

02:04:42.810 --> 02:04:44.690
halt in den Stellen, wo man auf

02:04:44.690 --> 02:04:46.250
ein Syscall wartet oder so, wo es blockiert,

02:04:47.230 --> 02:04:48.770
da macht man dann halt

02:04:48.770 --> 02:04:50.030
an einer anderen Stelle, wo man halt

02:04:50.030 --> 02:04:52.570
weitermachen kann, weiter. Und erst dann, wenn dann

02:04:52.570 --> 02:04:54.590
irgendein

02:04:54.590 --> 02:04:56.670
Lese, irgendein Read von

02:04:56.670 --> 02:04:58.630
irgendwie Netzwerkgeschichte zurückkommt, dann geht's

02:04:58.630 --> 02:04:59.590
halt dann da wieder weiter.

02:05:01.530 --> 02:05:02.650
Ja, also insofern

02:05:02.650 --> 02:05:04.450
würde ich sagen, also wenn man jetzt erst damit

02:05:04.450 --> 02:05:06.030
anfängt, dann ist Async.io wahrscheinlich die

02:05:06.030 --> 02:05:08.150
interessantere Geschichte, die man sich angucken sollte,

02:05:08.470 --> 02:05:10.190
weil es mehr aussieht

02:05:10.190 --> 02:05:11.150
wie ein normales Programm.

02:05:12.410 --> 02:05:14.150
Aber Threading kann man durchaus

02:05:14.150 --> 02:05:16.130
auch machen und ist wahrscheinlich sogar

02:05:16.130 --> 02:05:17.850
ein bisschen schneller, wenn man wenig Threads hat.

02:05:18.790 --> 02:05:20.110
Aber das ist eigentlich auch

02:05:20.110 --> 02:05:21.290
furchtbar, das spielt alles keine große Rolle.

02:05:22.630 --> 02:05:23.990
Okay. Ja, dann

02:05:23.990 --> 02:05:24.770
was ist Coverage?

02:05:26.710 --> 02:05:27.270
Oh, wuh!

02:05:28.150 --> 02:05:28.770
Ganz anderes Thema.

02:05:30.350 --> 02:05:31.610
Ja, meinst du das

02:05:31.610 --> 02:05:33.710
Paket oder das Modul? Die Testabdeckung. Achso, die Coverage.

02:05:33.890 --> 02:05:34.850
Ja, sozusagen wie viel

02:05:34.850 --> 02:05:39.870
ja, damit gibt man sozusagen an, wie viel

02:05:39.870 --> 02:05:41.570
Prozent des

02:05:41.570 --> 02:05:43.090
Codes

02:05:43.090 --> 02:05:45.530
durchlaufen wird, den man geschrieben hat,

02:05:45.590 --> 02:05:47.590
wenn man die Tests, also man kann ja halt

02:05:47.590 --> 02:05:49.690
gucken, auch das geht natürlich in Python ganz gut,

02:05:50.110 --> 02:05:51.670
es gibt auch ein Module-Coverage-PUI,

02:05:52.250 --> 02:05:53.730
das das macht, das halt guckt,

02:05:53.870 --> 02:05:55.670
wie viele von den Zeilen wurden

02:05:55.670 --> 02:05:57.590
denn aufgerufen, wenn ich jetzt

02:05:57.590 --> 02:05:59.610
die Tests durchlaufen lasse von meinem Gesamtding

02:05:59.610 --> 02:06:01.570
und das ist dann halt sozusagen, die Coverage ist halt sozusagen

02:06:01.570 --> 02:06:03.530
die Prozentzahl und wenn ich halt 70%

02:06:03.530 --> 02:06:04.390
habe, dann ist es halt

02:06:04.390 --> 02:06:07.590
besser, als wenn ich 50% habe.

02:06:08.050 --> 02:06:08.950
Wie viel sollte man denn davon haben?

02:06:09.410 --> 02:06:11.390
Es gibt Leute, die sagen, man sollte 100% haben.

02:06:11.870 --> 02:06:12.270
150?

02:06:13.350 --> 02:06:14.410
Weiß ich nicht so genau,

02:06:15.350 --> 02:06:16.750
ob das ein sinnvolles Ziel ist,

02:06:17.450 --> 02:06:19.410
weil es dann manche Sachen sind einfach schwer zu testen

02:06:19.410 --> 02:06:19.730
und

02:06:19.730 --> 02:06:23.190
irgendwann wird es halt dann sehr

02:06:23.190 --> 02:06:24.310
aufwendig und also

02:06:24.310 --> 02:06:27.330
die ersten 80% sind es, wie das so immer ist,

02:06:27.490 --> 02:06:29.230
die gehen relativ einfach und dann die letzten

02:06:29.230 --> 02:06:30.890
20% brauchen dann nochmal

02:06:30.890 --> 02:06:32.910
80% der Zeit

02:06:32.910 --> 02:06:34.930
irgendwie, weil das halt alles so

02:06:34.930 --> 02:06:36.350
fiese Fälle sind, die man nicht gut testen kann.

02:06:36.950 --> 02:06:38.790
Und dann ist halt die Frage, ist es noch sinnvoll, da so viel Zeit

02:06:38.790 --> 02:06:40.770
reinzustecken, weil den größten Nutzen

02:06:40.770 --> 02:06:42.510
hat man dann vielleicht schon gehabt, irgendwie

02:06:42.510 --> 02:06:44.910
in dem Code,

02:06:45.050 --> 02:06:46.590
der halt einfach zu testen war. Aber

02:06:46.590 --> 02:06:48.850
auch da kann man das natürlich vereinfachen, indem man

02:06:48.850 --> 02:06:50.670
einen Code so schreibt, dass man ihn einfach testen kann.

02:06:50.830 --> 02:06:52.670
Also manchmal mache ich Funktionen, schreibe ich Funktionen nur

02:06:52.670 --> 02:06:53.950
deswegen, um

02:06:53.950 --> 02:06:56.970
diese Funktionen einzeln testen zu können.

02:06:58.270 --> 02:06:58.530
Und

02:06:58.530 --> 02:07:00.590
ja, oder manchmal

02:07:00.590 --> 02:07:02.650
macht es Sinn, Dinge auf eine bestimmte Art

02:07:02.650 --> 02:07:04.430
zu strukturieren, sodass man sie halt leichter testen kann,

02:07:04.490 --> 02:07:06.450
als wenn man jetzt irgendwie alles in einer Funktion hat

02:07:06.450 --> 02:07:08.050
oder so, dann ist halt einfach schwer, die zu testen.

02:07:09.610 --> 02:07:10.490
Ja, und

02:07:10.490 --> 02:07:12.350
möglichst hohe Coverage ist natürlich gut.

02:07:12.650 --> 02:07:14.170
Also ich bin jetzt nicht so,

02:07:14.510 --> 02:07:16.390
ich will jetzt nicht sagen, dass 100% unbedingt notwendig ist,

02:07:16.450 --> 02:07:17.450
aber viel wäre schon gut.

02:07:18.930 --> 02:07:20.070
Und dann gibt es natürlich nochmal

02:07:20.070 --> 02:07:22.470
auch feine Unterschiede, ob man jetzt nur

02:07:22.470 --> 02:07:24.250
irgendwie durch den Code

02:07:24.250 --> 02:07:26.410
durchgelaufen ist, hat man aber auch wirklich alle,

02:07:26.730 --> 02:07:28.370
gibt es für jede unterschiedliche,

02:07:28.950 --> 02:07:30.190
also wenn man sowas wie

02:07:30.190 --> 02:07:32.310
Condition, so

02:07:32.310 --> 02:07:36.150
Also, if-else-Geschichten hat man sichergestellt,

02:07:36.210 --> 02:07:38.170
dass man alle Branches, die dann passieren können,

02:07:38.230 --> 02:07:38.990
durchlaufen hat und so.

02:07:39.430 --> 02:07:41.530
Insofern ist nicht mehr so ganz klar, was gemeint ist,

02:07:41.550 --> 02:07:42.570
wenn man jetzt Coverage sagt.

02:07:43.630 --> 02:07:46.610
Und ja, das kann man dann auch noch mal ...

02:07:46.610 --> 02:07:49.330
Also, ich glaube, die ursprüngliche Geschichte ist nur so,

02:07:49.550 --> 02:07:51.870
es ist egal, es müssen nicht alle Branches durchlaufen werden.

02:07:53.210 --> 02:07:55.030
Und das will man vielleicht auch anders haben.

02:07:55.030 --> 02:07:57.010
Also, ich glaube, das kann man auch bei Coverage noch einstellen.

02:07:58.550 --> 02:07:59.110
Etwas feiner.

02:07:59.350 --> 02:08:01.470
ja, genau. Das Test-Coverage ist halt

02:08:01.470 --> 02:08:02.990
sozusagen ein Maß dafür, wie viel

02:08:02.990 --> 02:08:04.290
von dem Code, der

02:08:04.290 --> 02:08:07.230
in deiner Bibliothek ist oder so, wie viel davon

02:08:07.230 --> 02:08:09.450
ist eigentlich durch Tests überprüft

02:08:09.450 --> 02:08:11.330
oder ist überhaupt mal

02:08:11.330 --> 02:08:13.070
ausgeführt worden bei einem Test.

02:08:16.130 --> 02:08:17.330
Ja, dann haben wir fast

02:08:17.330 --> 02:08:19.250
ja schon die letzte Frage. Ich glaube, wir sind da schon ziemlich lange wieder

02:08:19.250 --> 02:08:21.270
heute dabei. Und zwar

02:08:21.270 --> 02:08:23.170
auch wieder eine Hörerfrage.

02:08:23.570 --> 02:08:25.270
Wie man die Performance, die Speichernutzung

02:08:25.270 --> 02:08:27.110
der Codes prüfen und vergleichen kann?

02:08:29.350 --> 02:08:32.650
Ja, also

02:08:32.650 --> 02:08:37.130
was ich oft mache, ist tatsächlich

02:08:37.130 --> 02:08:39.130
aber das, ich meine, ist ja die Frage, wann das

02:08:39.130 --> 02:08:41.050
Sinn macht. Das macht eigentlich erst dann Sinn, wenn man

02:08:41.050 --> 02:08:42.330
viel Hauptspeicher verbraucht.

02:08:42.970 --> 02:08:45.090
Und ich mache das tatsächlich oft so,

02:08:45.270 --> 02:08:46.470
dass ich einfach mir

02:08:46.470 --> 02:08:49.270
die Ausgabe von Top angucke.

02:08:50.230 --> 02:08:50.990
Und dann sehe ich schon

02:08:50.990 --> 02:08:53.130
Systemausgabe, wie viel Speicher

02:08:53.130 --> 02:08:55.010
noch frei ist. Ja, und wie viel

02:08:55.010 --> 02:08:57.130
Speicher verbraucht ein Prozess.

02:08:57.590 --> 02:08:59.030
Und wenn dann halt

02:08:59.030 --> 02:09:00.910
irgendwas läuft, dann weiß ich ungefähr,

02:09:01.030 --> 02:09:02.130
wie viel Speicher das verbrauchen sollte.

02:09:02.710 --> 02:09:04.890
Und wenn das doppelt oder dreimal so viel verbraucht, dann

02:09:04.890 --> 02:09:07.030
weiß ich, dass ich da ein Problem

02:09:07.030 --> 02:09:08.230
habe und vielleicht nochmal irgendwas machen muss.

02:09:09.390 --> 02:09:10.710
Es gibt aber auch systematische

02:09:10.710 --> 02:09:12.730
Ansätze. Also es gibt

02:09:12.730 --> 02:09:14.550
zum Beispiel auch eingebauten Profiler

02:09:14.550 --> 02:09:16.910
in Python.

02:09:17.050 --> 02:09:19.150
C-Profile heißt, glaube ich, das Modul.

02:09:19.290 --> 02:09:20.870
Genau. Das kann

02:09:20.870 --> 02:09:22.590
aber mit Memory-Geschichten nicht so viel machen.

02:09:23.590 --> 02:09:25.030
Für Memory-Sachen

02:09:25.030 --> 02:09:26.590
glaube ich, da nimmt man dann eher so ein bisschen

02:09:26.590 --> 02:09:28.870
K-Cache-Grind oder sowas. Aber das

02:09:28.870 --> 02:09:31.050
ist, ich hab das...

02:09:31.050 --> 02:09:32.910
Aber wenn man das jetzt im Jupyter-Notebook machen möchte, weil man jetzt

02:09:32.910 --> 02:09:34.610
keinen Pop hat oder sowas und...

02:09:34.610 --> 02:09:37.130
Naja, du kannst dir halt von den Datenstrukturen

02:09:37.130 --> 02:09:38.850
anzeigen lassen, wie viel

02:09:38.850 --> 02:09:39.630
Speicher sie verbrauchen.

02:09:40.790 --> 02:09:42.350
Da hab ich jetzt auch wieder vergessen, das wusste ich.

02:09:42.970 --> 02:09:44.730
Also du kannst in dem Panas-Data-Frame

02:09:44.730 --> 02:09:46.930
sagen, irgendwie meminfo oder info

02:09:46.930 --> 02:09:48.870
oder sowas und dann deep gleich true

02:09:48.870 --> 02:09:50.830
oder sowas, dann geht das halt, macht das

02:09:50.830 --> 02:09:52.610
rekursiv, geht das durch

02:09:52.610 --> 02:09:54.770
diesen Data-Frame durch und guckt halt, wie viel

02:09:54.770 --> 02:09:56.730
Hauptspeicher brauchen da

02:09:56.730 --> 02:09:58.630
all die Dinge, die da drin sind und sagt dir halt am Ende

02:09:58.630 --> 02:10:00.630
eine Zahl. Und dann weißt du halt, okay, in diesem Ding

02:10:00.630 --> 02:10:02.590
stecken jetzt noch so viele Speicher drin.

02:10:03.950 --> 02:10:04.490
Dein ganzes

02:10:04.490 --> 02:10:06.510
Jupyter-Notebook, also so kannst du deine einzelnen

02:10:06.510 --> 02:10:07.690
Datenstrukturen angucken. Bei

02:10:07.690 --> 02:10:10.410
NumPy-Arrays ist es halt viel einfacher noch.

02:10:10.570 --> 02:10:12.010
Ich glaube, da gibt es auch eine Funktion, die einem sagt,

02:10:12.090 --> 02:10:14.730
wie ich den Hauptspeicher irgendwie in Array verwendet.

02:10:14.770 --> 02:10:16.510
Aber da ist es ja einfach, du kannst dir den D-Type

02:10:16.510 --> 02:10:18.430
angucken von dem Ding und du kannst

02:10:18.430 --> 02:10:20.390
ja auch angucken mit Shape, wie viel da drin liegt.

02:10:20.490 --> 02:10:21.890
Und dann multiplizierst du das einfach mit,

02:10:22.410 --> 02:10:24.530
wie viel Bit hat halt irgendwie

02:10:24.530 --> 02:10:26.510
der Typ, den ich da verwende, mal Anzahl Einträge

02:10:26.510 --> 02:10:28.390
und dann weißt du, wie groß es ist, weil da ist es halt sehr

02:10:28.390 --> 02:10:28.650
einfach.

02:10:32.190 --> 02:10:32.630
Also

02:10:32.630 --> 02:10:34.290
so kann man bei einzelnen Sachen rausfinden, wie viel

02:10:34.290 --> 02:10:36.270
Hauptspeicher die verbrauchen, weil das, wie viel das

02:10:36.270 --> 02:10:38.350
ein Jupyter-Notebook insgesamt verbraucht, siehst du halt

02:10:38.350 --> 02:10:39.070
im Top.

02:10:39.950 --> 02:10:41.130
Und der Speed?

02:10:42.490 --> 02:10:43.930
Ja, da brauchst du wahrscheinlich auch ein,

02:10:44.110 --> 02:10:45.870
also kannst du natürlich auch global

02:10:45.870 --> 02:10:48.070
das bestimmen,

02:10:48.270 --> 02:10:50.130
indem du halt, also auf der Shell schreibe ich auf

02:10:50.130 --> 02:10:51.550
Time einfach davor und dann

02:10:51.550 --> 02:10:53.770
kriege ich halt dann eine Ausgabe, wie viel,

02:10:54.790 --> 02:10:56.430
wie lange es gedauert hat

02:10:56.430 --> 02:10:58.370
bei Jupyter-Notebook-Zellen

02:10:58.370 --> 02:11:00.370
es gibt es auch halt irgendwie so eine Prozent-Time-Magie.

02:11:01.390 --> 02:11:02.310
Du kannst aber, wenn du

02:11:02.310 --> 02:11:04.450
jetzt einen Benchmark machen möchtest, dafür ist es natürlich nicht gut,

02:11:04.490 --> 02:11:06.250
das einmal auszuführen oder zweimal,

02:11:06.490 --> 02:11:08.410
sondern da möchte man das halt ein paar Mal

02:11:08.410 --> 02:11:10.510
ausführen, sodass halt dann auch so Cache-Effekte

02:11:10.510 --> 02:11:11.810
und so nicht so eine Rolle spielen.

02:11:12.430 --> 02:11:14.230
Und da gibt es dann halt auch

02:11:14.230 --> 02:11:16.310
Prozent-Time-It-Magie,

02:11:16.530 --> 02:11:18.450
wo das dann halt 10.000 Mal ausgeführt wird und dann

02:11:18.450 --> 02:11:20.230
wird dann halt Durchschnitt berechnet und dann

02:11:20.230 --> 02:11:22.270
ist es okay, diese Funktion dauert irgendwie

02:11:22.270 --> 02:11:24.450
üblicherweise 1,7

02:11:24.450 --> 02:11:25.290
Nanosekunden,

02:11:25.290 --> 02:11:27.530
äh, Millisekunden, Nanosekunden

02:11:27.530 --> 02:11:28.250
mehr schnell für die Funktion.

02:11:29.650 --> 02:11:31.430
Und dann weiß man halt, okay, wenn ich die jetzt

02:11:31.430 --> 02:11:33.130
so und so oft aufrufe, dann dauert das halt.

02:11:34.090 --> 02:11:34.170
Ja.

02:11:34.930 --> 02:11:35.290
Okay.

02:11:37.310 --> 02:11:38.850
Genau. Und ansonsten eben

02:11:38.850 --> 02:11:40.890
C-Profile kann man verwenden,

02:11:41.210 --> 02:11:43.410
wenn man jetzt noch gar keine Ahnung hat,

02:11:43.450 --> 02:11:45.350
wenn man nachgucken möchte und dann

02:11:45.350 --> 02:11:47.530
rauskriegen möchte, welche Funktion wird eigentlich am häufigsten

02:11:47.530 --> 02:11:49.190
aufgerufen und wie lange verbringt

02:11:49.190 --> 02:11:51.030
mein System sozusagen

02:11:51.030 --> 02:11:53.230
in welchen Funktionen, dann

02:11:53.230 --> 02:11:55.170
ist halt so ein Profile eine

02:11:55.170 --> 02:11:56.890
ganz hilfreiche Geschichte.

02:11:57.070 --> 02:11:58.570
Und dann, wenn man weiß, wo man Zeit verbringt,

02:11:58.650 --> 02:12:00.690
dann kann man halt mit TimeIt zum Beispiel

02:12:00.690 --> 02:12:02.650
in der Notebook-Zelle halt dann irgendwie

02:12:02.650 --> 02:12:04.250
gucken, ob man das irgendwie optimiert kriegt.

02:12:04.410 --> 02:12:06.170
Und dann kann man so die heißen

02:12:06.170 --> 02:12:08.610
Funktionen ein bisschen

02:12:08.610 --> 02:12:09.530
optimieren und dann sollte

02:12:09.530 --> 02:12:12.870
das schneller werden.

02:12:13.670 --> 02:12:14.030
Ja.

02:12:14.970 --> 02:12:15.330
Ja.

02:12:16.090 --> 02:12:18.610
Das war die letzte Frage, glaube ich, für heute. Ich glaube, wir sind tatsächlich

02:12:18.610 --> 02:12:20.730
irgendwie durch. Wir haben viel geredet

02:12:20.730 --> 02:12:22.210
über Python selbst irgendwie.

02:12:22.730 --> 02:12:23.730
Ich hoffe, das fandet ihr wieder interessant.

02:12:24.290 --> 02:12:24.450
Genau.

02:12:26.570 --> 02:12:28.410
Genau, haben wir noch irgendwie Picks oder sowas?

02:12:28.770 --> 02:12:29.850
Pick der Woche? Ja.

02:12:32.250 --> 02:12:33.110
Bis Monats.

02:12:35.290 --> 02:12:35.650
Ja.

02:12:37.310 --> 02:12:38.310
Also ich hätte da noch was.

02:12:38.610 --> 02:12:40.670
Ja, was ist dein Pick der Monats?

02:12:43.110 --> 02:12:44.550
Und zwar, ich habe

02:12:44.550 --> 02:12:46.550
mich letztens wieder damit

02:12:46.550 --> 02:12:48.830
beschäftigt, eine Rechnung neu aufzusetzen

02:12:48.830 --> 02:12:50.730
und

02:12:50.730 --> 02:12:52.330
habe dann nochmal so

02:12:52.330 --> 02:12:54.590
irgendwie angeguckt, ob es nicht, wie macht man

02:12:54.590 --> 02:12:56.670
das eigentlich vernünftige Python-Entwicklungsumgebung

02:12:56.670 --> 02:12:58.650
aufsetzen. Dazu gab es

02:12:58.650 --> 02:12:59.110
einen

02:12:59.110 --> 02:13:02.590
Artikel von

02:13:02.590 --> 02:13:04.210
Jacob Kaplan-Moss, glaube ich,

02:13:04.910 --> 02:13:06.210
einer der Django

02:13:06.210 --> 02:13:09.110
Gründer

02:13:09.110 --> 02:13:10.710
da, hat dazu

02:13:10.710 --> 02:13:12.870
irgendwie meine Python-Entwicklungsumgebung

02:13:12.870 --> 02:13:14.690
2020 Edition oder so ein Artikel

02:13:14.690 --> 02:13:15.990
geschrieben, das sollte ich mal verlinken.

02:13:16.650 --> 02:13:18.710
Und da dachte ich so, ah gut, dann gucke ich doch mal, was der so

02:13:18.710 --> 02:13:20.750
macht und wie ich das so mache

02:13:20.750 --> 02:13:22.930
und das, worauf

02:13:22.930 --> 02:13:24.950
eine Geschichte, auf die ich da gestoßen bin, die ich

02:13:24.950 --> 02:13:26.970
vorher nicht so verwendet habe, weiß gar nicht genau

02:13:26.970 --> 02:13:28.910
warum. Ich habe schon davon gehört und haben mir Leute

02:13:28.910 --> 02:13:30.910
davon erzählt, aber habe es irgendwie nicht benutzt, ist

02:13:30.910 --> 02:13:31.590
PyEnv.

02:13:33.350 --> 02:13:35.030
Und das war so eine der Geschichten,

02:13:35.250 --> 02:13:36.910
die ich, also genau, das wäre jetzt beim

02:13:36.910 --> 02:13:38.950
Tick PyEnv. Und das

02:13:38.950 --> 02:13:40.730
ist eigentlich ziemlich cool, weil

02:13:40.730 --> 02:13:42.430
das ist halt

02:13:42.430 --> 02:13:43.730
ein kleines

02:13:43.730 --> 02:13:46.990
Tool, was einem

02:13:46.990 --> 02:13:49.070
dabei hilft, halt Python zu installieren,

02:13:49.070 --> 02:13:51.010
was überraschend schwer ist. Es sollte eigentlich nicht so schwer sein,

02:13:51.090 --> 02:13:51.590
aber es ist halt

02:13:51.590 --> 02:13:53.710
ganz schön ätzend.

02:13:53.830 --> 02:13:55.650
Vor allen Dingen braucht man Python oft

02:13:55.650 --> 02:13:57.810
in sehr unterschiedlichen Versionen,

02:13:58.030 --> 02:14:00.090
unterschiedlichen Arten, wie man es installiert.

02:14:00.090 --> 02:14:02.050
Für manche Projekte brauche ich halt

02:14:02.050 --> 02:14:04.130
Minikonda oder Konda

02:14:04.130 --> 02:14:05.450
und

02:14:05.450 --> 02:14:08.150
benutze auch Konda zum Installieren

02:14:08.150 --> 02:14:09.590
von irgendwelchen Abhängigkeiten und so

02:14:09.590 --> 02:14:12.470
und Paketen. In anderen Webentwicklungsgeschichten

02:14:12.470 --> 02:14:13.870
wieder Virtual Envs und

02:14:13.870 --> 02:14:15.970
da auch wieder

02:14:15.970 --> 02:14:17.630
einen anderen Python-Interpreter,

02:14:17.790 --> 02:14:19.830
möglicherweise halt einfach einen, der über

02:14:19.830 --> 02:14:21.330
Homebrew gekommen ist oder

02:14:21.330 --> 02:14:23.670
den ich einfach so installiert habe oder sowas.

02:14:25.210 --> 02:14:25.930
Ja, und

02:14:25.930 --> 02:14:27.830
ja, also

02:14:27.830 --> 02:14:30.090
das war immer so ein bisschen

02:14:30.090 --> 02:14:32.090
doof und mit PyInf ist das eigentlich relativ

02:14:32.090 --> 02:14:33.990
einfach. Da sagt man dann halt, okay, ich hätte

02:14:33.990 --> 02:14:35.950
gern, also der

02:14:35.950 --> 02:14:37.830
installiert dann halt auch, PyInf installiert halt auch

02:14:37.830 --> 02:14:38.690
Miniconda und sowas.

02:14:39.690 --> 02:14:41.670
Und dann kann man halt sagen, okay,

02:14:41.810 --> 02:14:43.770
PyInf install Miniconda latest

02:14:43.770 --> 02:14:45.930
und dann hat man halt die, muss man

02:14:45.930 --> 02:14:47.750
nicht mehr sich damit beschäftigen, da irgendwie dieses

02:14:47.750 --> 02:14:48.850
Shell-Skript, also die

02:14:48.850 --> 02:14:50.830
Curl in irgendwie

02:14:50.830 --> 02:14:53.010
Shellscript zu pipen und dann

02:14:53.010 --> 02:14:55.050
Minicon dazu installieren, sondern das passiert

02:14:55.050 --> 02:14:56.550
alles für einen automatisch

02:14:56.550 --> 02:14:57.830
und

02:14:57.830 --> 02:15:01.290
man kann halt auch pro Verzeichnis dann definieren,

02:15:01.450 --> 02:15:03.150
was denn jetzt der Interpreter

02:15:03.150 --> 02:15:05.010
ist, der ausgeführt werden soll, wenn man jetzt da

02:15:05.010 --> 02:15:06.770
Python eingibt. Da gibt es dann so

02:15:06.770 --> 02:15:09.010
einen Punkt Python-Version-File

02:15:09.010 --> 02:15:11.010
und da steht das dann halt einfach drin. Und das kann halt

02:15:11.010 --> 02:15:12.510
auch ein

02:15:12.510 --> 02:15:15.110
Name von einem Virtual Env sein. Dann ist man halt

02:15:15.110 --> 02:15:16.570
in diesem Virtual Env.

02:15:17.110 --> 02:15:18.310
Oder es kann halt der Name sein

02:15:18.310 --> 02:15:19.150
von einem Condor-Environment.

02:15:20.090 --> 02:15:22.050
Und das ist halt sehr, sehr cool.

02:15:22.170 --> 02:15:23.970
Das heißt, ich hatte vorher sonst immer

02:15:23.970 --> 02:15:27.130
einen Virtual-Env-Wrapper verwendet

02:15:27.130 --> 02:15:29.550
und dann immer so Post-Activate-Skripten.

02:15:32.230 --> 02:15:34.610
Einmal dann halt,

02:15:36.230 --> 02:15:37.330
ich überlege gerade,

02:15:37.390 --> 02:15:38.410
ob das nicht ein anderes Thema ist,

02:15:38.410 --> 02:15:41.770
aber nee, ins Verzeichnis gewechselt

02:15:41.770 --> 02:15:42.870
und dann noch so Dinge gemacht und so.

02:15:43.070 --> 02:15:45.170
Und das geht eigentlich quasi mittlerweile

02:15:45.170 --> 02:15:46.410
alles relativ automatisch

02:15:46.410 --> 02:15:47.450
und man muss halt auch nicht mehr

02:15:47.450 --> 02:15:50.390
work on irgendwas sagen,

02:15:50.450 --> 02:15:52.270
sondern man geht einfach in das Verzeichnis und dann ist

02:15:52.270 --> 02:15:54.270
gut. Also es funktioniert noch nicht alles

02:15:54.270 --> 02:15:56.090
hundertprozentig. Das ist auch noch so eine Idee.

02:15:56.390 --> 02:15:58.110
Ich glaube, ich packe das irgendwo

02:15:58.110 --> 02:16:00.190
wo packe ich denn das am besten hin? Ich habe mir das

02:16:00.190 --> 02:16:02.230
mal versucht irgendwann aufzuschreiben sozusagen, was ich

02:16:02.230 --> 02:16:02.790
da alles tue

02:16:02.790 --> 02:16:06.210
und was man so an hilfreichen Tools

02:16:06.210 --> 02:16:08.270
da verwenden kann. Vielleicht packe

02:16:08.270 --> 02:16:09.970
ich das irgendwo auf GitHub in Gist oder so.

02:16:10.830 --> 02:16:12.310
Vielleicht haben andere Leute ja auch noch Ideen,

02:16:12.350 --> 02:16:14.030
was man da an tollen Dingen machen kann.

02:16:14.030 --> 02:16:16.010
Und vor allen Dingen, manche Sachen funktionieren auch nicht so ganz

02:16:16.010 --> 02:16:17.690
sauber. Also von irgendwie

02:16:17.690 --> 02:16:19.970
Virtual-Env nach Conda wechseln, das geht irgendwie,

02:16:19.990 --> 02:16:21.450
aber umgekehrt geht irgendwie nicht oder so.

02:16:21.830 --> 02:16:22.470
Weiß nicht genau, warum.

02:16:24.890 --> 02:16:25.650
Ja, und

02:16:25.650 --> 02:16:27.950
vielleicht wäre das mal eine sinnvolle Geschichte, das mal zusammen

02:16:27.950 --> 02:16:29.990
zu tragen. Was muss man eigentlich machen, um halt eine ordentliche

02:16:29.990 --> 02:16:31.090
Python-Entwicklungsumgebung

02:16:31.090 --> 02:16:33.290
irgendwie aufzusetzen? Ja, das klingt auf jeden Fall

02:16:33.290 --> 02:16:35.630
nach einer guten Sache. Genau.

02:16:36.830 --> 02:16:38.210
Ja. Ja, und

02:16:38.210 --> 02:16:39.030
genau, Python

02:16:39.030 --> 02:16:41.070
fand ich jetzt sehr, sehr

02:16:41.070 --> 02:16:42.690
überzeugend eigentlich und

02:16:42.690 --> 02:16:44.190
bin ich eigentlich

02:16:44.190 --> 02:16:46.970
dachte ich mir, warum fände ich das jetzt eigentlich

02:16:46.970 --> 02:16:48.890
nicht schon immer sozusagen, weil das

02:16:48.890 --> 02:16:50.950
vereinfacht doch eine Menge Sachen deutlich.

02:16:52.170 --> 02:16:53.130
Ja, ich habe auch einen kleinen

02:16:53.130 --> 02:16:54.550
Pick der Woche. Ich nehme diesmal

02:16:54.550 --> 02:16:56.830
Turtle, diese kleine Bibliothek, mit der man

02:16:56.830 --> 02:16:58.710
kleine Sachen zeichnen kann auf einer Kenntnis.

02:16:58.710 --> 02:17:00.450
Ach, Turtle-Grafik, ja. Ja, weil da kann man tatsächlich

02:17:00.450 --> 02:17:02.610
ganz lustige Sachen machen, zum Beispiel Kunst.

02:17:02.790 --> 02:17:05.250
Man kann sich Algorithmen in die Mandelbrotmengen

02:17:05.250 --> 02:17:06.790
berechnen lassen, Funktionen, und der zeichnet

02:17:06.790 --> 02:17:08.990
dann ganz tolle, witzige Bilder,

02:17:08.990 --> 02:17:10.690
mit denen man Computerkunst macht.

02:17:11.430 --> 02:17:12.870
Also, unabhängig davon, dass man jetzt

02:17:12.870 --> 02:17:14.830
eine kleine Schildkröte über den Bildschirm bewegen kann,

02:17:14.910 --> 02:17:16.470
um einfache grafische Spielchen zu bauen.

02:17:16.970 --> 02:17:18.810
Das fand ich sehr witzig, deswegen wollte ich das noch mal

02:17:18.810 --> 02:17:20.950
picken. Ja, cool, cool,

02:17:21.010 --> 02:17:22.870
cool. Ja, vielen Dank

02:17:22.870 --> 02:17:24.970
fürs Zuhören. Egal wann ihr hört,

02:17:25.490 --> 02:17:26.230
montags, mittags,

02:17:26.810 --> 02:17:28.630
abends, nachts. Bleibt uns gewogen,

02:17:28.730 --> 02:17:30.590
habt viel Spaß und wir hören uns bald wieder.

02:17:30.770 --> 02:17:32.550
Ja, bis zum nächsten Mal. Tschüss. Tschüss.

02:18:12.870 --> 02:18:37.190
Auf Takt

02:18:37.190 --> 02:18:41.190
Intakt

02:18:42.870 --> 02:18:48.450
Im Viertag soll es klingeln.

02:18:50.990 --> 02:18:55.170
Dreiklangs, Dimensionen sind taktvoll.

02:18:58.130 --> 02:19:03.170
Lichtspiel, Impressionen, die Farbfarbe.

02:19:05.190 --> 02:19:09.730
Farbton, Halbton.

02:19:12.250 --> 02:19:17.210
Und Synchron, da zu schwingen.

02:19:19.710 --> 02:19:24.070
Drei Klangs, Dimensionen, so taktvoll.

02:19:26.930 --> 02:19:31.210
Lichtspiel, Impressionen, so fassvoll.

02:19:42.250 --> 02:19:56.770
Wohlklamm, Illusionen, die um uns herum tanzen.

02:19:58.770 --> 02:20:03.810
Drei Glanzdimensionen, so taktvoll.

02:20:06.230 --> 02:20:11.010
Licht spielt Impressionen, so farbvoll.

02:20:12.250 --> 02:20:25.750
Klänge für Millionen überwinden die Distanzen.

02:20:28.550 --> 02:20:32.750
Drei Klangsdimensionen, so taktvoll.

02:20:34.750 --> 02:20:39.950
Licht spielt Impressionen, so fachvoll.

02:20:42.250 --> 02:21:12.230
Bis zum nächsten Mal.

02:21:12.250 --> 02:21:42.230
Bis zum nächsten Mal.

02:21:42.250 --> 02:22:06.630
Ausgang

02:22:06.630 --> 02:22:10.190
Abgang

02:22:12.250 --> 02:22:17.690
Sequenzen, ohne Grenzen.

02:22:20.490 --> 02:22:24.650
Dreiklangs, Dimensionen, so taktvoll.

02:22:27.510 --> 02:22:31.850
Lichtspiel, Impressionen, so farbvoll.

02:22:34.430 --> 02:22:39.090
Dreiklangs, Dimensionen, so taktvoll.

02:22:41.510 --> 02:22:53.530
Lichtspiel, Impressionen, so farbvoll, Dreiklangs, Dimensionen, so taktvoll.

02:22:55.450 --> 02:23:07.970
Lichtspiel, Impressionen, so farbvoll, Dreiklangs, Dimensionen, so taktvoll.

02:23:10.430 --> 02:23:22.390
Licht spielt, Impressionen, so farbvoll, drei Klangs-Dimensionen, so taktvoll.

02:23:24.230 --> 02:23:36.810
Licht spielt, Impressionen, so farbvoll, drei Klangs-Dimensionen, so taktvoll.