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 2er-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.100
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.400
Spam, Spam, Spam, Spam, Spam, Spam.

00:07:35.400 --> 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.680
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.380 --> 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.500
Also die allermeisten haben damit Probleme und strugglen da

00:16:17.500 --> 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.840 --> 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.300
eigentlich ist es auch wieder so ein bisschen,

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

00:16:36.640 --> 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.980 --> 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.260
oder zu sagen, dass man irgendwas kann, auch wenn man es halt vielleicht nur so

00:16:58.260 --> 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.680
zwei Minuten.

00:17:12.260 --> 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.080 --> 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.920
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.440 --> 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.260
weil das schon viele Leute nicht so richtig hinkriegen

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

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

00:18:04.420 --> 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.760
nicht irgendwie Spaghetti-Gut schreibt, dass das halt alles so

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

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

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

00:18:15.720 --> 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.620 --> 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:41.200
irgendwie sich was besorgen, was man da...

00:18:41.200 --> 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.920
und dann lese ich jetzt von...

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

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

00:18:55.500 --> 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 da seinen eigenen Code anguckt,

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

00:19:11.160 --> 00:19:12.080
oh, was willst du sagen?

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

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

00:19:17.340 --> 00:19:18.960
Ja, was, erstmal,

00:19:19.220 --> 00:19:20.880
also ich habe noch eine Basisfrage bekommen von Olli,

00:19:20.960 --> 00:19:22.700
die hat ja noch geschrieben, Tipps für eine gute Syntax,

00:19:23.220 --> 00:19:24.680
dein Top 5 oder so.

00:19:25.980 --> 00:19:26.920
Ich, heute,

00:19:27.020 --> 00:19:28.960
heutzutage würde ich sagen, Black verwenden und nicht mehr

00:19:28.960 --> 00:19:29.620
drüber nachdenken.

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

00:19:32.680 --> 00:19:34.140
Also Namen vielleicht auch.

00:19:35.540 --> 00:19:36.980
Namen sind natürlich, das sind ganz,

00:19:36.980 --> 00:19:39.040
eine ganz schwierige Sache. Also wie kommt

00:19:39.040 --> 00:19:41.160
man da auf gute Namen? Da muss man auch lange drüber nachdenken

00:19:41.160 --> 00:19:42.480
oft. Also

00:19:42.480 --> 00:19:44.900
ja, da gibt es ja auch mal den bekannten

00:19:44.900 --> 00:19:47.060
Witz, was sind die zwei schwierigen

00:19:47.060 --> 00:19:47.320
Sachen?

00:19:48.960 --> 00:19:49.180
Ja,

00:19:50.260 --> 00:19:52.480
in der Informatik irgendwie

00:19:52.480 --> 00:19:54.920
Dinge benennen, Caching und

00:19:54.920 --> 00:19:55.820
oft bei One Error

00:19:55.820 --> 00:19:58.340
Errors. Ja, aber

00:19:58.340 --> 00:20:00.720
genau. Also Dinge benennen

00:20:00.720 --> 00:20:02.780
ist schwierig, ist eine Kunst und

00:20:02.780 --> 00:20:04.700
ja, wo man sich da auch dran

00:20:04.700 --> 00:20:06.640
orientieren kann, ist so ein bisschen wie bei

00:20:06.640 --> 00:20:08.680
guten Kommentaren, sollte er

00:20:08.680 --> 00:20:10.520
darauf achten, hinzuschreiben,

00:20:11.060 --> 00:20:12.580
warum man das macht oder was das macht.

00:20:13.180 --> 00:20:14.540
Nicht so sehr, wie da

00:20:14.540 --> 00:20:15.660
irgendwas passiert oder so.

00:20:18.020 --> 00:20:18.580
Ja, und

00:20:18.580 --> 00:20:20.620
halt dabei, wenn man verschreibt,

00:20:20.860 --> 00:20:22.540
dran denken, dass

00:20:22.540 --> 00:20:24.580
das, wenn das

00:20:24.580 --> 00:20:26.560
jemand liest, dann halt verständlich

00:20:26.560 --> 00:20:28.440
sein sollte, weil Code viel öfter gelesen wird,

00:20:28.560 --> 00:20:28.840
als geschrieben.

00:20:30.120 --> 00:20:30.940
Ja, okay.

00:20:32.640 --> 00:20:34.140
Was ist mit sowas wie List Comprehensions?

00:20:34.280 --> 00:20:36.320
Würdest du das bevorzugen gegenüber klassischen

00:20:36.320 --> 00:20:37.980
loben. Nö, kommt drauf an.

00:20:38.240 --> 00:20:40.160
Also ich würde sogar eher ein bisschen

00:20:40.160 --> 00:20:41.980
die andere, ich würde sagen

00:20:41.980 --> 00:20:43.880
lieber eine Vorschleife

00:20:43.880 --> 00:20:45.900
verwenden und List Comprehension

00:20:45.900 --> 00:20:47.540
halt eher dann, wenn es halt irgendwas

00:20:47.540 --> 00:20:49.180
einfacheres ist, wo

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

00:20:51.820 --> 00:20:54.000
dann kann man auch gerne List Comprehension

00:20:54.000 --> 00:20:55.840
verwenden, aber wenn man, also

00:20:55.840 --> 00:20:56.580
ich meine,

00:20:58.600 --> 00:20:59.900
auch da, das ist halt,

00:21:00.040 --> 00:21:01.660
wenn man irgendwas entdeckt, wie es funktioniert

00:21:01.660 --> 00:21:03.700
und das dann cool findet, dann fängt man an, das überall zu benutzen

00:21:03.700 --> 00:21:06.000
und ich habe dann auch schon nicht List Comprehensions

00:21:06.000 --> 00:21:08.020
gebaut, irgendwie, wo ich dann

00:21:08.020 --> 00:21:10.380
halt mehrfach

00:21:10.380 --> 00:21:12.100
verschachtelt irgendwie über Dinge iteriert habe

00:21:12.100 --> 00:21:14.180
und das wird bei List Comprehension sehr, sehr

00:21:14.180 --> 00:21:15.660
schnell, sehr, sehr unübersichtlich,

00:21:16.140 --> 00:21:18.180
wo ich dann halt irgendwie stolz darauf war, so ein Statement

00:21:18.180 --> 00:21:19.040
hingekriegt zu haben.

00:21:19.600 --> 00:21:22.200
Nicht in einer Zeile, das geht dann halt

00:21:22.200 --> 00:21:24.260
nicht mehr in einer Zeile, aber dann so drei Zeilen

00:21:24.260 --> 00:21:25.500
List Comprehension irgendwie

00:21:25.500 --> 00:21:27.940
mit Bedingungen drin und verschachtelt

00:21:27.940 --> 00:21:30.080
und so lange getüftelt, bis es

00:21:30.080 --> 00:21:32.120
irgendwie ordentlich funktioniert hat. Das macht ja dann

00:21:32.120 --> 00:21:33.900
auch irgendwie Spaß. Das ist halt so ein bisschen wie puzzeln,

00:21:34.560 --> 00:21:36.660
aber ich fürchte, wenn da jemand

00:21:36.660 --> 00:21:37.580
dann drauf guckt, der das

00:21:37.580 --> 00:21:40.560
verstehen muss und das

00:21:40.560 --> 00:21:42.080
unter einem gewissen Zeitdruck tut, dann

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

00:21:44.860 --> 00:21:46.100
Rot vor Wut.

00:21:46.840 --> 00:21:47.880
Spaß zur Ärger.

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

00:21:50.060 --> 00:21:52.480
das Remote Strangulation Protocol

00:21:52.480 --> 00:21:54.040
irgendwie zur Hilfe wünschen.

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

00:21:55.580 --> 00:21:55.800
Ja.

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

00:22:01.320 --> 00:22:02.560
Das kennt wahrscheinlich auch keiner.

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

00:22:04.560 --> 00:22:05.600
auch schon lange her,

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

00:22:07.440 --> 00:22:10.500
und da gibt es die SysAdmin,

00:22:10.940 --> 00:22:12.260
also es gibt die SysAdmin

00:22:12.260 --> 00:22:13.180
ManPages oder die

00:22:13.180 --> 00:22:16.300
SysAdmin Recovery,

00:22:16.460 --> 00:22:17.240
gab es eine News Group

00:22:17.240 --> 00:22:20.360
und dann ASR,

00:22:20.700 --> 00:22:22.220
Alt SysAdmin Recovery,

00:22:22.620 --> 00:22:24.520
das war die News Group und dann gab es die ASR

00:22:24.520 --> 00:22:25.600
ManPages und Tools.

00:22:26.240 --> 00:22:28.720
Ich glaube, wenn man ManASR

00:22:28.720 --> 00:22:30.100
sagt oder ManKnife oder

00:22:30.100 --> 00:22:32.220
Mansnip oder so, dann

00:22:32.220 --> 00:22:34.320
kriegt man das auch noch irgendwie auf dem Linux

00:22:34.320 --> 00:22:36.540
zu sehen. Da gibt es dann Tools,

00:22:36.720 --> 00:22:38.240
mit denen man irgendwie Usern

00:22:38.240 --> 00:22:40.680
die

00:22:40.680 --> 00:22:42.480
Attitüde von Usern

00:22:42.480 --> 00:22:44.480
wieder rejustieren kann

00:22:44.480 --> 00:22:46.120
und diese Tools sind halt sowas wie

00:22:46.120 --> 00:22:47.380
Snip

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

00:22:49.960 --> 00:22:52.780
mit der Axt

00:22:52.780 --> 00:22:54.080
irgendwie mal dazwischen geht und

00:22:54.080 --> 00:22:55.380
Dinge gerade richtet.

00:22:55.500 --> 00:22:58.280
Die Attitüde von Usern regulieren, das hört sich toll an.

00:22:58.880 --> 00:22:59.520
Ja, das klingt

00:22:59.520 --> 00:23:02.320
nach Spaß an, wenn man auf der

00:23:02.320 --> 00:23:03.060
richtigen Seite steht.

00:23:04.280 --> 00:23:05.380
Ja, ist natürlich so ein bisschen,

00:23:05.700 --> 00:23:07.560
ich meine, das Mindset dahinter ist auch etwas fragwürdig,

00:23:07.700 --> 00:23:09.800
aber es ist damals was irgendwie lustig.

00:23:10.180 --> 00:23:11.940
Und da gab es auch Protokolle

00:23:11.940 --> 00:23:13.760
und eines der Protokolle in dem Zusammenhang ist halt,

00:23:13.760 --> 00:23:19.060
dass RSTP, RS, weiß nicht,

00:23:19.200 --> 00:23:20.760
eben Remote Strangulation Protokoll

00:23:21.300 --> 00:23:24.760
über Fernverbindungen.

00:23:25.240 --> 00:23:26.200
Sehr gut, sehr gut.

00:23:26.320 --> 00:23:29.260
Ja, das ist das, was man in Startorganisationen gerne hätte

00:23:29.260 --> 00:23:31.380
oder wo man dran arbeitet, das automatisch zu bekommen.

00:23:31.660 --> 00:23:33.480
Also ihr braucht gute Admins für den Start,

00:23:33.560 --> 00:23:34.200
damit das funktioniert.

00:23:34.280 --> 00:23:37.640
Ja, also okay, ein bisschen

00:23:37.640 --> 00:23:39.580
Syntax haben wir gemacht, ja, also die Frage wäre

00:23:39.580 --> 00:23:41.580
jetzt noch, was gehört als zu Python Fullstack

00:23:41.580 --> 00:23:43.640
dann, also wenn man jetzt schon ganz viel kann und so,

00:23:43.680 --> 00:23:45.400
was würdest du sagen, wenn man richtig Fullstack entwickelt?

00:23:45.520 --> 00:23:47.580
Ja, Fullstack, das ist so ein Ding, was heutzutage

00:23:47.580 --> 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.220
auch das, ich mach das nicht eigentlich,

00:23:55.220 --> 00:23:57.220
ich bin deutlich eher auf der Backend-Seite als auf der

00:23:57.920 --> 00:23:59.080
Frontend-Seite, aber Fullstack

00:23:59.080 --> 00:24:01.120
hieße ja, dass du quasi alles machen kannst,

00:24:01.200 --> 00:24:02.700
von unten bis Frontend.

00:24:02.700 --> 00:24:04.160
Also Full-Second-Python geht gar nicht, weil

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

00:24:06.440 --> 00:24:08.580
bist du halt nicht, da brauchst

00:24:08.580 --> 00:24:09.840
du halt dann schon JavaScript für

00:24:09.840 --> 00:24:12.120
und ja, oder

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

00:24:14.360 --> 00:24:16.200
ein Bereich, der schön wäre, wenn das mit Python

00:24:16.200 --> 00:24:18.340
funktionieren würde, aber momentan geht das nicht richtig.

00:24:18.500 --> 00:24:20.560
Also man könnte natürlich Python auch irgendwie Richtung

00:24:20.560 --> 00:24:22.340
WebAssembly kompilieren

00:24:22.340 --> 00:24:24.360
und dann halt im Frontend verwenden, aber es gibt

00:24:24.360 --> 00:24:25.760
keine, es gibt

00:24:25.760 --> 00:24:28.040
eben nicht so viel wie für JavaScript die ganzen

00:24:28.040 --> 00:24:30.260
UI-Bibliotheken, die man da so braucht,

00:24:30.400 --> 00:24:32.080
um halt Dinge irgendwie auszumachen.

00:24:32.520 --> 00:24:34.020
Also, schwierig.

00:24:35.000 --> 00:24:35.220
Ja, okay.

00:24:36.080 --> 00:24:38.040
Ja, das heißt, JavaScript braucht ihr, wenn ihr Full-Tag machen wollt.

00:24:38.140 --> 00:24:39.680
Und mit nur 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.780 --> 00:24:43.900
weil warum sollte man Full-Tag machen, wenn man nicht andere Sachen

00:24:43.900 --> 00:24:45.500
wie Data und Backend so gut kann?

00:24:45.520 --> 00:24:48.000
Naja, also wenn du eine Webseite machst, hast du halt sofort

00:24:48.000 --> 00:24:49.900
diesen ganzen Kram, wobei du da möglicherweise

00:24:49.900 --> 00:24:52.020
eben auch ohne JavaScript oder ohne viel

00:24:52.020 --> 00:24:53.320
JavaScript auskommen kannst.

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

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

00:24:57.660 --> 00:25:00.080
Ein bisschen CSS könntest du vielleicht schon machen oder sowas.

00:25:00.080 --> 00:25:01.300
Ja, auch kein Python.

00:25:01.780 --> 00:25:04.000
auch wieder kein Python, genau. Aber das

00:25:04.000 --> 00:25:05.880
geht natürlich auch immer noch und ist eigentlich auch

00:25:05.880 --> 00:25:07.600
für viele Anwendungen irgendwie

00:25:07.600 --> 00:25:09.700
gar nicht so schlecht. Aber

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

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

00:25:14.600 --> 00:25:15.980
Naja, also ohne da was. Aber das ist

00:25:15.980 --> 00:25:17.540
ja was anderes. Ja, also Fullstack geht gar nicht

00:25:17.540 --> 00:25:19.880
nur mit Python. Ja, und das

00:25:19.880 --> 00:25:21.620
ist tatsächlich auch einer der großen

00:25:21.620 --> 00:25:23.760
Risiken irgendwie

00:25:23.760 --> 00:25:25.300
für die Zukunft von Python, wenn das halt

00:25:25.300 --> 00:25:27.560
quasi so aus dem Wettding, weil

00:25:27.560 --> 00:25:29.860
die Frage ist jetzt, kommt Python

00:25:29.860 --> 00:25:30.820
nochmal ins Frontend oder

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

00:25:33.140 --> 00:25:35.580
und wenn der Weg in die Zukunft so aussieht,

00:25:35.640 --> 00:25:37.420
das wird dann JavaScript, weil das natürlich auch gewisse

00:25:37.420 --> 00:25:38.780
Vorteile bringt. Du kannst, Marcel, dann

00:25:38.780 --> 00:25:40.920
schreibst du einmal den Code, kannst ihn im Backend und

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

00:25:43.580 --> 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.780 --> 00:25:51.360
Oder es läuft umgekehrt

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

00:25:53.380 --> 00:25:55.560
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.620
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.620 --> 00:26:04.760
Also ich glaube, Python ist noch bei Anfängern gerade ein bisschen beliebter.

00:26:04.820 --> 00:26:07.780
Vielleicht bedeutet das, dass das irgendwann dann auch in diese Richtung driftet.

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

00:26:10.280 --> 00:26:10.620
Wer weiß.

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

00:26:13.540 --> 00:26:15.000
Import-Sys, Son of Python.

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

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

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

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

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

00:26:29.100 --> 00:26:30.980
dann seht ihr das. Then of Python, also die Prinzipien,

00:26:31.420 --> 00:26:32.760
die man sich

00:26:32.760 --> 00:26:34.700
darauf geeinigt hat, die in Python gelten, sollen

00:26:34.700 --> 00:26:36.100
auch sein, wenn man die Anwendung versteht.

00:26:36.120 --> 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.380 --> 00:26:42.760
Ja, das ist direkt verknüpft zu

00:26:42.760 --> 00:26:44.480
PEP 8. Ich glaube, das hatten wir dann auch schon mal kurz erwähnt.

00:26:44.820 --> 00:26:46.800
Ja, das ist sozusagen einfach nur die

00:26:46.800 --> 00:26:47.980
Art, wie man

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

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

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

00:26:54.640 --> 00:26:55.920
sollte, vielleicht.

00:26:57.440 --> 00:26:58.520
Wer macht das nicht, dann kommt

00:26:58.520 --> 00:27:00.620
hier in die Python. Ja, aber

00:27:00.620 --> 00:27:02.520
auch innerhalb von Tab 8 gibt es ja so Dinge,

00:27:02.640 --> 00:27:03.800
die dann nicht geklärt sind dadurch

00:27:03.800 --> 00:27:05.000
und

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

00:27:08.440 --> 00:27:10.540
dazu, wie das sein soll. Du kannst ja Dinge machen, die

00:27:10.540 --> 00:27:12.020
Ich finde bei einigen Sachen total furchtbar, das sieht

00:27:12.020 --> 00:27:14.120
scheußlich aus. Okay, was denn?

00:27:14.720 --> 00:27:16.320
Ja, wenn ich zum Beispiel Argumente

00:27:16.320 --> 00:27:18.400
in Funktionen packe oder

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

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

00:27:22.480 --> 00:27:24.400
dann macht er die Klammer auf

00:27:24.400 --> 00:27:26.320
in eine Zeile, dann nächste Zeile den

00:27:26.320 --> 00:27:28.380
String aus dem Print Statement und dann da drunter

00:27:28.380 --> 00:27:30.500
die Klammer wieder zu, wo ich dann

00:27:30.500 --> 00:27:32.420
sagen würde, hey, für die fünf Zeilen extra, wenn

00:27:32.420 --> 00:27:34.480
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.360
Oder halt, wenn Kommentare am Ende der

00:27:38.360 --> 00:27:40.320
Zeile sind, dann bricht ja dann trotzdem

00:27:40.320 --> 00:27:42.360
die ganze Funktion auseinander, obwohl sie noch reinpassen würde.

00:27:43.020 --> 00:27:43.920
Oder wenn

00:27:43.920 --> 00:27:45.800
Black sagt,

00:27:46.360 --> 00:27:47.800
ganz viele Argumente in einer Funktion,

00:27:48.240 --> 00:27:50.120
bricht das dann aber um, weil es nicht genug Argumente sind, um

00:27:50.120 --> 00:27:52.180
auf jeder Zeile ein Argument zu haben.

00:27:52.680 --> 00:27:54.300
Das sieht auch ganz furchtbar aus.

00:27:54.440 --> 00:27:56.560
Und dann ist dann der, Klammer zu, mit dem Doppelpunkt

00:27:56.560 --> 00:27:58.660
dann am Anfang von einer Zeile

00:27:58.660 --> 00:28:00.140
irgendwie drei Zeilen

00:28:00.140 --> 00:28:02.260
Funktionsdefinition. Das finde ich total

00:28:02.260 --> 00:28:04.360
furchtbar. Ich bin eh nicht so ein Freund

00:28:04.360 --> 00:28:05.580
von diesem 89 Zeichen

00:28:05.580 --> 00:28:07.720
Editor-Quatsch, weil ganz ehrlich,

00:28:08.840 --> 00:28:10.200
so Enzien, dass wir nur

00:28:10.200 --> 00:28:11.400
89 Zeichen auf dem Bildschirm haben.

00:28:11.620 --> 00:28:13.700
79. Ja, 79. Entschuldigung.

00:28:14.080 --> 00:28:15.660
Ich entwickle nicht die ganze Zeit mit meinem Telefon.

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

00:28:19.200 --> 00:28:20.360
Die haben halt bloß 80

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

00:28:22.460 --> 00:28:23.080
80

00:28:23.080 --> 00:28:25.080
Spalten.

00:28:26.280 --> 00:28:28.020
Und es gibt natürlich,

00:28:28.160 --> 00:28:30.000
oder ich weiß nicht. Ja, die alten, aber nur

00:28:30.000 --> 00:28:30.460
also die neuen.

00:28:31.920 --> 00:28:33.860
Weiß ich nicht, ob es da, ne, ne, der Standard ist immer noch so.

00:28:34.000 --> 00:28:35.940
Also wenn, ist auch so, wenn du, wenn du

00:28:35.940 --> 00:28:37.940
jetzt auf dem Linux oder so bist, dann hast du ja nicht unbedingt immer

00:28:37.940 --> 00:28:39.900
ein grafisches System und deine Konsole sieht halt

00:28:39.900 --> 00:28:41.020
so aus. Da gibt es keinen.

00:28:41.900 --> 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.440 --> 00:28:49.500
Ja, ich,

00:28:49.800 --> 00:28:52.080
also ohne grafische Benutzeroberfläche

00:28:52.080 --> 00:28:53.480
glaube ich, ist schwierig. Aber auf der anderen Seite

00:28:53.480 --> 00:28:55.480
wahrscheinlich gibt es diesen Fall,

00:28:55.820 --> 00:28:57.840
dass jemand an einem Rechner ohne grafische Benutzeroberfläche sitzt,

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

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

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

00:29:01.680 --> 00:29:02.980
Ja, natürlich, aber du hast...

00:29:02.980 --> 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.680
an einem Rechnerzentrum, an eine serielle Konsole?

00:29:08.680 --> 00:29:12.740
Ich glaube, da hast du genau die 80 Spalten und 24...

00:29:12.740 --> 00:29:13.800
Das ist ja uralt, DOS.

00:29:14.780 --> 00:29:16.140
Ja, bei DOS war das auch so, genau.

00:29:17.680 --> 00:29:20.140
Ja, ich weiß auch nicht.

00:29:21.180 --> 00:29:22.120
Also ich glaube auch nicht,

00:29:22.160 --> 00:29:23.040
das ist eigentlich nicht mehr relevant,

00:29:23.240 --> 00:29:24.860
aber da kommt das halt her.

00:29:25.360 --> 00:29:26.920
Das heißt, wenn, dann sieht man da halt, muss man kurz

00:29:26.920 --> 00:29:28.980
drauf aufpassen, dass es dann umgebrochene Zeilen

00:29:28.980 --> 00:29:30.920
gibt, die automatisch vielleicht

00:29:30.920 --> 00:29:32.860
eingruckt werden oder so. Ich weiß gar nicht,

00:29:32.900 --> 00:29:34.820
auf was ich es gestellt habe bei mir. Das ist ja auch

00:29:34.820 --> 00:29:36.640
ein Ding, das man bei Black tatsächlich einstellen kann.

00:29:36.840 --> 00:29:38.920
Also da, das

00:29:38.920 --> 00:29:40.640
muss man nicht so auf 79

00:29:40.640 --> 00:29:42.820
zeichnen lassen. Also 79 zeichnen deswegen, weil man halt

00:29:42.820 --> 00:29:44.020
noch eins braucht von den Zeilen.

00:29:47.040 --> 00:29:48.460
Aber wenn,

00:29:49.340 --> 00:29:50.620
also ich glaube, ich habe es auch irgendwo auf

00:29:50.620 --> 00:29:52.040
einer 10 stehen, aber ich weiß es nicht.

00:29:52.840 --> 00:29:54.780
Jedenfalls, das kann man ja konfigurieren und dann ist es nicht mehr

00:29:54.780 --> 00:29:56.780
so schlimm. Also ich finde auch ein bisschen mehr als 80 geht

00:29:56.780 --> 00:29:58.740
schon. Irgendwann ist es natürlich auch wieder doof,

00:29:58.780 --> 00:29:59.520
wenn das halt zu lang wird.

00:30:00.300 --> 00:30:02.540
Also so, dass man es halt vernünftig auf einem normalen

00:30:02.540 --> 00:30:04.620
Arbeitsrechner irgendwie vernünftig anlesen kann, dass es dann nicht immer

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

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

00:30:08.720 --> 00:30:10.420
Also ich finde, DECK ist dann so ein bisschen inkonsistent,

00:30:10.500 --> 00:30:12.620
wenn es halt dann, beispielsweise

00:30:12.620 --> 00:30:14.560
du hast drei Debug-Statements hintereinander, das eine

00:30:14.560 --> 00:30:16.800
ist vier Zeichen zu lang, dann bricht der jetzt ganz komisch rum

00:30:16.800 --> 00:30:18.820
irgendwie und die anderen darunter

00:30:18.820 --> 00:30:20.440
sehen nicht so aus.

00:30:20.500 --> 00:30:21.960
Das ist irgendwie komisch.

00:30:23.500 --> 00:30:24.500
Also ich finde das

00:30:24.500 --> 00:30:26.640
wo mein ästhetisches Empfinden wird, da immer so ein bisschen

00:30:26.640 --> 00:30:27.660
angehört. Naja, gut.

00:30:30.260 --> 00:30:30.880
Wann ist man

00:30:30.880 --> 00:30:31.880
Amnesie-Syndrom erkrankt?

00:30:32.740 --> 00:30:34.540
Ah, not invented

00:30:34.540 --> 00:30:35.260
hier, ja.

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

00:30:37.260 --> 00:30:40.700
ja, ja, ja.

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

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

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

00:30:46.540 --> 00:30:48.580
Genau, das heißt einfach nur, dass man

00:30:48.580 --> 00:30:50.320
halt versucht, alles selber zu machen und

00:30:50.320 --> 00:30:52.400
wenn es halt nicht von hier kommt, oder so viele

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

00:30:54.120 --> 00:30:56.140
alles doof finden, was sie nicht selber gemacht haben und dann

00:30:56.140 --> 00:30:58.140
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.060 --> 00:31:02.180
Genau. Das ist halt immer nett, da kann man immer was damit lernen.

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

00:31:04.120 --> 00:31:05.780
schlicht und hat man irgendwann nicht

00:31:05.780 --> 00:31:08.160
keinen mehr, der versteht, wie es irgendwann mal gebaut worden ist.

00:31:08.580 --> 00:31:10.080
Es sind nur noch Leute, die dann irgendwie auf dem

00:31:10.080 --> 00:31:12.220
Sand und der Asche von alten versunkenen

00:31:12.220 --> 00:31:13.660
Stieten versuchen, neue Gebäude zu errichten.

00:31:14.060 --> 00:31:15.580
Und dann immer so, oh, da war eine Grube.

00:31:16.760 --> 00:31:18.020
Und dann steht es ja Palast zusammen.

00:31:18.100 --> 00:31:19.740
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.360 --> 00:31:23.600
Aber natürlich kann man ja viel Zeit damit

00:31:23.600 --> 00:31:25.620
verschwinden, dass man einfach anfängt, komplett

00:31:25.620 --> 00:31:27.600
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 halt eine richtige

00:31:33.440 --> 00:31:35.080
Balance finden. Es ist manchmal gut,

00:31:36.500 --> 00:31:37.680
Dinge, also ein Beispiel dafür

00:31:37.680 --> 00:31:39.680
wäre auch dieses Timestamp-Modell

00:31:39.680 --> 00:31:41.480
aus den Model-Utils. Ja, deswegen haben alle

00:31:41.480 --> 00:31:43.400
als Abhängigkeit Model-Utils drin.

00:31:44.360 --> 00:31:45.380
Dabei, ja,

00:31:46.220 --> 00:31:47.300
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.660
auch

00:31:51.660 --> 00:31:52.420
gesprochen und

00:31:52.420 --> 00:31:58.200
Und dann hat er dann so, naja, das sind halt eigentlich zwei Zeilen irgendwie in einem Modell, wenn man das selber macht.

00:31:59.680 --> 00:32:09.080
Vielleicht wäre es besser gewesen, die beiden Zeilen dann selber hinzuschreiben und dann diese Abhängigkeit nicht zu haben, weil jetzt hat man halt das Problem, dass wenn man, das ist ja auch wieder blöd, wenn man nichts selber macht.

00:32:09.660 --> 00:32:12.240
Ganz schlimmen NPM hat das ja auch so bei JavaScript-Geschichten.

00:32:12.940 --> 00:32:19.840
Dann hast du halt, musst du dich halt viel mit dieser Maintenance von diesem Kram beschäftigen, was ja auch blöd ist.

00:32:19.840 --> 00:32:33.080
Ja, Parc-V-Resonierung muss immer stimmen und genau dem Zustand bleiben und wenn du irgendwelche Bugs hast, musst du dann irgendwas updaten, weil irgendwas kritisch war und das hat dann andere Abhängigkeiten und dann fliegt dir irgendwas auseinander, weil das inkompatibel ist mit irgendeiner neuen Implementierung von irgendeiner, ja.

00:32:33.240 --> 00:32:54.220
Also man kann nicht sagen, das eine ist super schlecht, das andere ist, sondern man muss halt irgendwie einen Weg finden, der für den Anwendungsfall, den man hat, den besten Trade-Off bietet. Aber tatsächlich ist es so, dass die meisten Leute eher zu viel Richtung Not-Invented hier gehen.

00:32:55.940 --> 00:32:57.720
Ja, manchmal ist das praktisch.

00:32:57.760 --> 00:32:58.900
Ich glaube, manchmal ist es auch gar nicht so schlecht,

00:32:58.960 --> 00:33:00.320
wenn man einfach coole Sachen, die cool funktionieren,

00:33:00.360 --> 00:33:02.580
einfach benutzen kann und die dann cool weiter funktionieren

00:33:02.580 --> 00:33:05.540
und dann auch einem schnell irgendwas ermöglichen zu entwickeln.

00:33:05.880 --> 00:33:07.320
Ich glaube, gerade für Anfänger ist das gar nicht so schlecht,

00:33:07.420 --> 00:33:09.080
wenn man halt nicht von ganz immer anfängt.

00:33:09.340 --> 00:33:10.140
Obwohl es natürlich auch nett ist,

00:33:10.180 --> 00:33:11.980
wenn man vielleicht erst mal Assembler lernt und dann C

00:33:11.980 --> 00:33:13.660
und dann irgendwie guckt, wie es alles so funktioniert.

00:33:13.780 --> 00:33:15.600
Aber es ist auch vielleicht ein bisschen aufwendig.

00:33:15.700 --> 00:33:17.860
Man kann vielleicht auch ab und zu mal eine High-Level-Bibliothek

00:33:17.860 --> 00:33:20.600
einfach benutzen, um zu gucken, wie man Dinge damit anstellt,

00:33:20.700 --> 00:33:23.100
ohne direkt alles zu verstehen und das selber zu implementieren.

00:33:23.100 --> 00:33:50.140
Ja, über die Zeit ist es natürlich so, dass auch der Level an Abstraktion, auf dem man arbeitet, wird immer höher eigentlich, weil halt immer mehr wird Commodity, also die Sachen, die früher der interessante Bereich war, in dem man irgendwas gemacht hat, die werden halt zunehmend Community und wandern halt sozusagen aus dem interessanten Feld raus und das, wo man die interessanten Sachen machen kann, das geht über die Zeit immer in abstrakter Geschichten.

00:33:50.140 --> 00:34:19.460
Das ist halt auch die Frage, inwiefern das nicht unter Umständen, also auf der einen Seite kann man sagen, man kann halt mit viel weniger Zeilencode irgendwie viel kompliziertere Dinge und tollere Sachen bauen, auf der anderen Seite ist es halt, wenn man sich das manchmal genauer anguckt, steht das alles so ein bisschen auf tönernen Füßen, das ist halt so Kartenhaus über Kartenhaus geschichtet und irgendwie auf den unteren Ebenen stimmen schon viele Sachen nicht mehr so richtig, aber dann baut man halt so lange Abstraktionen drüber, bis es wieder, also ja, aber in Wirklichkeit hat man diese Probleme nicht wirklich gelöst.

00:34:19.460 --> 00:34:21.160
Wenn man halt das Gebäude, den Palast aus der Sandgrube

00:34:21.160 --> 00:34:23.040
baut, man kann tatsächlich noch ein paar Stahlträger einziehen,

00:34:23.120 --> 00:34:24.900
das dann zu tun hat, könnte der Palast auch gehalten werden.

00:34:24.940 --> 00:34:26.340
Das ist halt dann, ja.

00:34:28.020 --> 00:34:28.340
Ja.

00:34:29.820 --> 00:34:31.480
Aha. Ja, aber jetzt gehen wir, glaube ich,

00:34:31.480 --> 00:34:33.080
jetzt haben wir so ein bisschen generell darüber gesprochen,

00:34:33.320 --> 00:34:35.380
was so, ne, Python generell,

00:34:35.440 --> 00:34:37.460
was das so ausmacht. Jetzt gehen wir so ein bisschen tiefer

00:34:37.460 --> 00:34:38.860
in die Probleme der,

00:34:39.660 --> 00:34:41.580
oder was heißt die Probleme, die Ideen, die Konzepte

00:34:41.580 --> 00:34:43.360
der eigentlichen Sprache, so, was man auch vielleicht

00:34:43.360 --> 00:34:45.340
achten muss. Also, falls ihr noch Fragen habt, die ich nicht beantwortet

00:34:45.340 --> 00:34:46.560
hatte, ne, schreibt uns wieder, wie immer,

00:34:47.100 --> 00:34:48.600
hallo at pythonpodcast.de, so.

00:34:49.460 --> 00:34:50.320
Wofür ist die InetPy?

00:34:53.160 --> 00:34:54.060
Das ist eine gute Frage.

00:34:54.720 --> 00:34:55.960
Ja, man braucht das irgendwie,

00:34:56.220 --> 00:34:58.700
damit es ein Paket ist.

00:35:00.860 --> 00:35:03.080
Ein Modul, wo ist der Unterschied zwischen Modulen und Paketen?

00:35:03.160 --> 00:35:03.480
Oh mein Gott.

00:35:03.880 --> 00:35:05.560
Ich glaube, das muss ich ja selber nochmal nachlesen.

00:35:05.860 --> 00:35:08.440
Damit der Namespace irgendwie vernünftig zugegriffen werden kann.

00:35:08.540 --> 00:35:09.800
Also alles, was man da irgendwie reinpackt,

00:35:09.840 --> 00:35:11.520
das sitzt dann im Namespace dieses Moduls,

00:35:11.560 --> 00:35:12.900
wenn man es importiert, direkt drin.

00:35:13.860 --> 00:35:14.320
Irgendwie so.

00:35:14.420 --> 00:35:16.480
Und dann kann man da direkt aktiv drauf zugreifen.

00:35:16.780 --> 00:35:17.640
Aber die Frage ist halt,

00:35:17.640 --> 00:35:19.340
warum man das dann nicht mit den Submodulen macht.

00:35:19.960 --> 00:35:21.940
Du kannst das ja auch

00:35:21.940 --> 00:35:24.120
reinschreiben, was du

00:35:24.120 --> 00:35:25.940
exportieren willst, welche Symbole.

00:35:27.820 --> 00:35:28.400
Interessanter Fall ist,

00:35:28.400 --> 00:35:29.500
kann man da auch Sachen ausschließen?

00:35:29.820 --> 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.580 --> 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.000
Module selber bauen kann. Ich glaube, das Einzige, was man machen

00:35:42.000 --> 00:35:44.220
muss, ist halt ein Folder importieren.

00:35:44.500 --> 00:35:45.900
Also, indem man halt relativ

00:35:45.900 --> 00:35:47.880
Zugriff drauf hat und dann einfach

00:35:47.880 --> 00:35:50.180
sagen, Import-Folder-Name

00:35:50.180 --> 00:35:51.920
oder sowas. Und wenn da eine Inis-Pi drin ist,

00:35:52.020 --> 00:35:54.000
dann kann man die Module, die da drin sind,

00:35:54.060 --> 00:35:56.040
einfach aufrufen mit

00:35:56.040 --> 00:35:57.100
seinem Import-Teil. Und dann kann man

00:35:57.100 --> 00:36:00.320
Modul-Verzeichnis-Name, 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:35.410
Aber ja, also sollte man nicht, ist auch eher so interner Gebrauch.

00:38:35.530 --> 00:38:37.770
Ja, aber es ist jetzt nicht so total privat.

00:38:40.150 --> 00:38:42.750
Ja, also es ist eine Konvention.

00:38:43.190 --> 00:38:51.370
Im Grunde braucht man das auch, also außer jetzt manchmal bei Double Underscore eigentlich auch nicht wirklich.

00:38:52.270 --> 00:38:56.250
Also ich habe zum Beispiel diese internen Variablen habe ich noch nicht verstanden, wofür das gut ist.

00:38:56.310 --> 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.110
Methoden, die es identifiziert, überschreiben will,

00:39:04.170 --> 00:39:05.250
um andere Effekte zu erzeugen.

00:39:06.510 --> 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.170
da nicht

00:39:11.170 --> 00:39:14.270
wirklich mit interagieren

00:39:14.270 --> 00:39:16.390
sollte. Nicht umfummeln, ich fasse meine Klassen nicht an.

00:39:17.190 --> 00:39:18.270
Alles, was man selber schreibt,

00:39:18.270 --> 00:39:19.970
kann man immer anders kaufordern, wie man anderes

00:39:19.970 --> 00:39:20.610
anfasst.

00:39:21.110 --> 00:39:23.910
Ich versuche mal ein Beispiel zu geben, also wenn du

00:39:23.910 --> 00:39:26.170
eine Klasse hast, die irgendwas casht, dann

00:39:26.170 --> 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.270
also hat ein Property-Dekorator drüber, irgendwas

00:39:38.270 --> 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.230 --> 00:39:47.070
gibst du einfach das

00:39:47.070 --> 00:39:49.950
den gecacheten Wert zurück

00:39:49.950 --> 00:39:52.070
und ansonsten rechnest du es halt neu aus,

00:39:52.170 --> 00:39:53.930
unter bestimmten Bedingungen.

00:39:54.470 --> 00:40:01.010
Und den Cache selber, den legt man oft dann in so einem Underscore-Attribut ab.

00:40:01.030 --> 00:40:01.670
Underscore-Cache.

00:40:02.070 --> 00:40:06.770
Ja, oder Underscore, dieser Name dieses Attributes oder so.

00:40:07.930 --> 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:12.990
dann kriege ich vielleicht den gecacheten Wert.

00:40:13.450 --> 00:40:15.030
Aber ich kenne ja jetzt gar nicht die Bedingungen,

00:40:15.190 --> 00:40:18.330
unter denen das vielleicht den Cache invalidieren müsste oder so.

00:40:18.330 --> 00:40:20.070
Und wenn ich da jetzt einfach so drauf zugreife,

00:40:20.690 --> 00:40:24.250
dann kann sein, dass Dinge schief gehen.

00:40:24.470 --> 00:40:25.070
Und

00:40:25.070 --> 00:40:27.990
das heißt, ja, das ist halt so eine Markierung

00:40:27.990 --> 00:40:30.030
für das Ding hier bitte nicht direkt

00:40:30.030 --> 00:40:32.090
verwenden, sondern dann gibt es ja meistens

00:40:32.090 --> 00:40:34.190
ein öffentliches

00:40:34.190 --> 00:40:36.070
Attribut, was man benutzen

00:40:36.070 --> 00:40:37.990
kann und dann kann die Klasse das intern

00:40:37.990 --> 00:40:39.650
handeln, wie sie das integriert.

00:40:41.910 --> 00:40:44.330
Ja, im Grunde

00:40:44.330 --> 00:40:45.170
eine Schnittstelle,

00:40:45.470 --> 00:40:47.350
die Schnittstelle zu irgendwas.

00:40:47.830 --> 00:40:49.330
Das gibt es jetzt auch in unterschiedlichen

00:40:49.330 --> 00:40:52.050
Kontexten kann man das

00:40:52.050 --> 00:40:53.670
verwenden, aber ich würde jetzt mal sagen, also

00:40:53.670 --> 00:40:55.530
üblicherweise, wenn man jetzt irgendein Paket

00:40:55.530 --> 00:40:57.610
verwendet,

00:40:58.030 --> 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.230 --> 00:41:03.770
dann ist die API das,

00:41:03.930 --> 00:41:05.830
was man sozusagen von außen benutzt.

00:41:06.130 --> 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.110
kann, um die

00:41:11.110 --> 00:41:13.610
für den Anwendungsfall...

00:41:13.610 --> 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.370
request.get, macht halt ein get-Request.

00:41:19.510 --> 00:41:21.570
Das ist halt der öffentliche. Intern macht

00:41:21.570 --> 00:41:23.150
das dann unter Umständen noch eine ganze Menge anderer

00:41:23.150 --> 00:41:25.270
Funktionsaufrufe und Dinge und weiß

00:41:25.270 --> 00:41:27.270
der Teufel. Und die sind aber intern

00:41:27.270 --> 00:41:28.750
gar nicht alle mit einem Underscore.

00:41:29.110 --> 00:41:31.250
Nö, also manche von denen kann ich auch einfach so verwenden, das ist ja

00:41:31.250 --> 00:41:33.410
auch kein Problem, aber andere wahrscheinlich

00:41:33.410 --> 00:41:35.290
auch eher nicht. Und die, die ich nicht unbedingt

00:41:35.290 --> 00:41:37.210
verwenden sollte von außen, die

00:41:37.210 --> 00:41:38.690
sind halt dann so markiert als

00:41:38.690 --> 00:41:40.370
für intern gebraucht.

00:41:41.430 --> 00:41:43.130
Ja. Was ist eine private

00:41:43.130 --> 00:41:44.990
und eine globale Variable und was ist der Unterschied

00:41:44.990 --> 00:41:45.990
und wofür braucht man das?

00:41:47.130 --> 00:41:49.350
Global, privat. Also privat, öffentlich,

00:41:49.470 --> 00:41:51.170
das ist halt so ein bisschen, aber das hat man

00:41:51.170 --> 00:41:53.110
in Python eigentlich auch gar nicht so wahnsinnig

00:41:53.110 --> 00:41:55.010
viel. Also in anderen Programmiersprachen gibt es da

00:41:55.010 --> 00:41:57.190
eine stärkere Unterscheidung,

00:41:57.330 --> 00:41:59.070
aber im Grunde ist es einfach so.

00:41:59.070 --> 00:42:01.210
Also ich hatte es gerade so in den Anfängertagen

00:42:01.210 --> 00:42:02.710
ganz oft so, dass ich irgendwie mir dachte,

00:42:02.890 --> 00:42:05.090
private Variablen, das ist alles irgendwie

00:42:05.090 --> 00:42:06.850
ein bisschen blöd. Ich muss ja irgendwie von der Funktion immer

00:42:06.850 --> 00:42:09.070
irgendwie so einen Wert returnen und damit das dann, also ich glaube

00:42:09.070 --> 00:42:11.270
im Kontext einer Funktion sind ja eigentlich die Variablen

00:42:11.270 --> 00:42:12.870
immer privat. Nein, nein, nein, nee,

00:42:12.970 --> 00:42:15.110
das ist eine Verwechslung. Also du meinst lokal.

00:42:15.430 --> 00:42:16.150
Lokal und global.

00:42:16.870 --> 00:42:19.110
Privat und öffentlich, das ist halt genau

00:42:19.110 --> 00:42:20.510
diese Geschichte mit dem Double Underscore.

00:42:20.510 --> 00:42:22.590
Ja, okay. Dann meinte ich lokal

00:42:22.590 --> 00:42:38.710
Und global, ja. Also lokal heißt, Variablen sind halt quasi in dem Block gültig. Und ich habe immer gehört, man braucht keine globalen, man darf die nicht nehmen oder es ist total nicht so backrested.

00:42:38.810 --> 00:42:39.330
Kann man schon.

00:42:39.890 --> 00:42:50.670
An einigen Stellen habe ich halt gemerkt, also gerade ich habe mal so Spielereien gemacht, Spiele gebaut oder sowas, da hat es immer total super geholfen, weiß ich nicht, die Lebensenergie des kleinen Männchens global zu definieren, anstatt in einer Funktion oder so.

00:42:51.290 --> 00:43:10.090
Ja, kann man durchaus machen. Es gibt auch Fälle, wo das durchaus praktische Anwendungsfälle hat. Es kommt halt darauf an, was man damit machen möchte. Man muss das halt explizit als global markieren, wenn man das tun möchte.

00:43:10.090 --> 00:43:11.790
und dann gibt es auch 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.770
aber

00:43:16.770 --> 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.310 --> 00:43:26.290
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.190
Variablen hat, die man ändert, dann

00:43:30.190 --> 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:35.990
als ob da irgendwas nicht so richtig ordentlich

00:43:35.990 --> 00:43:36.750
funktioniert, weil

00:43:36.750 --> 00:43:39.830
was

00:43:39.830 --> 00:43:41.690
möchte man damit eigentlich machen? Also man

00:43:41.690 --> 00:43:44.150
hat da irgendwie State, auf den man zugreift

00:43:44.150 --> 00:43:45.930
von unterschiedlichen Stellen, also es wird dann halt sehr schwer

00:43:45.930 --> 00:43:48.110
zu 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.830
und an unterschiedlichen Stellen des Codes

00:43:51.830 --> 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.990 --> 00:44:01.810
Das Problem beim Programmieren ist dann halt irgendwie,

00:44:01.930 --> 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.750 --> 00:44:08.210
was an allen anderen Stellen

00:44:08.210 --> 00:44:10.570
im Code, an dem an diesem Ding

00:44:10.570 --> 00:44:11.810
irgendwie rumgeschraubt wird, auch passiert.

00:44:12.350 --> 00:44:14.490
Warum? Also ich nehme jetzt mal so ein Beispiel, wo ich

00:44:14.490 --> 00:44:16.390
jetzt intuitiv sagen würde, das wäre jetzt

00:44:16.390 --> 00:44:18.790
für mich das, was ich jetzt als globale Variable

00:44:18.790 --> 00:44:20.150
haben würde. Ich habe jetzt ein Spiel,

00:44:20.730 --> 00:44:22.570
mein Barbar hat Lebensenergie von 100.

00:44:23.110 --> 00:44:24.450
Und es gibt bestimmte Funktionen, die

00:44:24.450 --> 00:44:26.390
aufgerufen werden, wenn der Barbar irgendwas

00:44:26.390 --> 00:44:28.330
macht, falsch macht, richtig macht, runterfällt,

00:44:28.450 --> 00:44:29.850
gegen einen anderen, gegen einen Monster kämpft,

00:44:30.330 --> 00:44:32.590
dann würde ich von dieser globalen Lebensenergie

00:44:32.590 --> 00:44:33.250
irgendwas abziehen.

00:44:35.870 --> 00:44:36.510
Wofür muss ich

00:44:36.510 --> 00:44:38.230
denn dann an der einen Stelle, wenn er jetzt,

00:44:38.290 --> 00:44:40.230
weiß ich nicht, auf ein Skelett trifft, dem Zehn

00:44:40.230 --> 00:44:42.430
Lebensenergie abzieht, wissen, was an der anderen Stelle

00:44:42.430 --> 00:44:43.810
die Falle mit ihm gemacht hat?

00:44:46.590 --> 00:44:47.910
Naja, also, weil du,

00:44:48.290 --> 00:44:50.310
weil ja, naja, lass mal überlegen,

00:44:50.430 --> 00:44:51.930
kann ich irgendwas konstruieren, was

00:44:51.930 --> 00:44:53.870
dann problematisch wird?

00:44:54.190 --> 00:44:56.510
Ich meine, es kann ja auch Dinge geben, die die Lebensenergie wieder erhöhen.

00:44:57.330 --> 00:44:57.790
Ein Trank.

00:44:58.070 --> 00:45:00.250
Ja, und du musst halt zum Beispiel, du musst halt

00:45:00.250 --> 00:45:02.090
wissen, dass das jetzt schon nicht unter

00:45:02.090 --> 00:45:03.610
Null gefallen ist, wenn du jetzt,

00:45:04.050 --> 00:45:05.450
sonst könntest du dich ja auch wieder

00:45:05.450 --> 00:45:07.650
lebendig machen, sozusagen,

00:45:07.750 --> 00:45:09.230
wenn du tot bist, eigentlich.

00:45:09.470 --> 00:45:10.510
Ein Lifehack, ja.

00:45:12.150 --> 00:45:13.550
Irgendwas muss diesen State verwalten.

00:45:13.670 --> 00:45:15.770
Irgendwas muss halt sagen, okay, jetzt bist du aber tot.

00:45:16.650 --> 00:45:17.330
Und dann darfst du nicht

00:45:17.330 --> 00:45:19.510
durch, darf nicht irgendein anderer Teil des

00:45:19.510 --> 00:45:21.010
Codes, der jetzt nicht weiß, ob du tot bist oder nicht,

00:45:21.630 --> 00:45:23.990
einfach deine Lebensenergie

00:45:23.990 --> 00:45:25.610
oder deine Lebenspunkte erhöhen, weil

00:45:25.610 --> 00:45:27.790
das macht dich ja eventuell wieder lebendig in einer Situation,

00:45:27.930 --> 00:45:28.610
wo das gar nicht gehen darf.

00:45:30.330 --> 00:45:31.530
Also, sozusagen,

00:45:31.730 --> 00:45:33.570
es ist... Also, das würde nicht so gut

00:45:33.570 --> 00:45:35.470
funktionieren. Das heißt, da würde man auch auch klassenbasiert

00:45:35.470 --> 00:45:37.550
einen Ansatz nehmen, wo man irgendwie sowas

00:45:37.550 --> 00:45:39.710
machen wie erhöhe Lebenspunkte und reduziere Lebenspunkte

00:45:39.710 --> 00:45:41.650
und der macht das halt dann nur dann, wenn man noch nicht tot ist

00:45:41.650 --> 00:45:43.530
oder so. Genau, und das erhöhe

00:45:43.530 --> 00:45:45.410
Lebenspunkte geht halt nur, solange man nicht tot ist zum Beispiel

00:45:45.410 --> 00:45:47.430
und so. Aber diese Logik, wie

00:45:47.430 --> 00:45:48.970
das funktioniert, wäre dann halt an einem

00:45:48.970 --> 00:45:51.370
Ort gebündelt. Das ist ja so ein bisschen die Idee auch hinter

00:45:51.370 --> 00:45:51.630
Klassen.

00:45:53.270 --> 00:45:55.370
Hinter Objektorientierter Programmierung, dass du

00:45:55.370 --> 00:45:56.890
halt die ganze Komplexität

00:45:56.890 --> 00:45:59.170
irgendwie verbirgst.

00:45:59.890 --> 00:46:00.250
Hinter

00:46:00.250 --> 00:46:02.670
ja, hinter dieser

00:46:02.670 --> 00:46:05.130
in diesem Objekt hinter einer API

00:46:05.130 --> 00:46:07.150
und dann das halt alles nicht mehr wissen

00:46:07.150 --> 00:46:08.990
musst. Während wenn du jetzt einfach nur eine Variable hast,

00:46:09.070 --> 00:46:10.050
die da irgendwie verändern kann,

00:46:10.970 --> 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.670
jetzt dann doch Sinn?

00:46:22.930 --> 00:46:25.010
Mir fällt da fast keins ein,

00:46:25.090 --> 00:46:25.930
wo das irgendwie sinnvoll ist.

00:46:26.610 --> 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.190
man etwas nur

00:46:32.190 --> 00:46:34.430
einmal hat oder so. Aber da

00:46:34.430 --> 00:46:36.530
würde man auch eher ein Singleton nehmen,

00:46:36.610 --> 00:46:38.070
beziehungsweise in Python eher Borg-Pattern.

00:46:38.070 --> 00:46:40.130
Oh, Singleton, das steht hier ein bisschen weiter unten. Ein Singleton.

00:46:40.570 --> 00:46:42.030
Ja. Borg-Pattern, hast du gerade gesagt?

00:46:42.770 --> 00:46:43.450
Ja, okay.

00:46:44.210 --> 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:48.990
Also sozusagen

00:46:48.990 --> 00:46:52.250
Singleton

00:46:52.250 --> 00:46:53.530
ist, wenn

00:46:53.530 --> 00:46:55.810
garantiert sein soll, dass es von einer bestimmten

00:46:55.810 --> 00:46:57.750
Geschichte nur eine Instanz gibt. Also wenn ich

00:46:57.750 --> 00:46:59.290
zum Beispiel eben

00:46:59.290 --> 00:47:01.090
Spiel

00:47:01.090 --> 00:47:04.630
die Spielfigur oder so, die dann bestimmte

00:47:04.630 --> 00:47:06.690
Eigenschaften hat, wie eben sowas wie Lebensenergie

00:47:06.690 --> 00:47:08.750
oder so, wenn ich garantieren

00:47:08.750 --> 00:47:10.550
möchte, dass alle, die damit interagieren,

00:47:10.650 --> 00:47:11.570
immer die gleiche Instanz sehen.

00:47:11.810 --> 00:47:14.510
Es gibt nur einen, es wäre jetzt blöd, wenn ich zwei

00:47:14.510 --> 00:47:16.090
davon erzeuge und dann in dem einen

00:47:16.090 --> 00:47:18.590
Objekt verlinke ich die Lebensenergie

00:47:18.590 --> 00:47:20.170
und beim anderen nicht oder so. Wie macht man das denn?

00:47:20.230 --> 00:47:21.970
Überschreibt man dann die New-Methode und sagt dann so,

00:47:22.070 --> 00:47:23.430
nee, wenn es schon eins gibt, dann mach keinen neuen?

00:47:24.330 --> 00:47:25.930
Ja, das ist, nee, eigentlich

00:47:25.930 --> 00:47:28.490
so, weil dann kommen wir zu dem Borg-Pattern,

00:47:28.550 --> 00:47:30.170
so wird das üblicherweise dann in Python implementiert,

00:47:30.790 --> 00:47:32.550
ist, man macht es einfach so, dass

00:47:32.550 --> 00:47:35.910
wie ging das da?

00:47:36.290 --> 00:47:37.310
Also ich glaube, der Trick ist,

00:47:38.210 --> 00:47:40.450
aber das muss man mal nachgucken, also mit Vorsicht genießen,

00:47:41.990 --> 00:47:43.450
ist, dass sozusagen

00:47:43.450 --> 00:47:45.790
den State innerhalb

00:47:45.790 --> 00:47:48.770
von der, eines Objekts

00:47:48.770 --> 00:47:50.270
sozusagen in der

00:47:50.270 --> 00:47:52.450
Klassenvariable zu halten, die halt bei allen Instanzen

00:47:52.450 --> 00:47:54.250
gleich ist. Und dann können die Instanzen

00:47:54.250 --> 00:47:55.950
zwar unterschiedlich sein, aber der State ist immer gleich.

00:47:57.270 --> 00:47:58.250
Und dann

00:47:58.250 --> 00:48:00.050
ist es zwar kein Singleton in dem Sinne,

00:48:00.270 --> 00:48:02.230
wie man das vielleicht ursprünglich mal

00:48:02.230 --> 00:48:04.110
so definiert hat. Im Gänger-Vorbuch gibt es

00:48:04.110 --> 00:48:05.750
halt das Pattern Singleton,

00:48:06.850 --> 00:48:08.330
weil man eben nicht immer

00:48:08.330 --> 00:48:09.490
tatsächlich, also ich glaube, die

00:48:09.490 --> 00:48:11.990
ursprünglichen Singleton-Beschreibungen, das wird einfach immer

00:48:11.990 --> 00:48:13.910
die gleiche Instanz

00:48:13.910 --> 00:48:15.990
retornt, wenn man halt die...

00:48:15.990 --> 00:48:17.930
Also das heißt nie überschreiben. Das würde halt bedeuten, wenn

00:48:17.930 --> 00:48:19.530
schon ein anderes gibt, retornt es halt das.

00:48:20.930 --> 00:48:21.850
Retornt es 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:27.590
und macht sozusagen

00:48:27.590 --> 00:48:29.590
verhält sich ähnlich und hat noch ein paar andere nette

00:48:29.590 --> 00:48:30.010
Vorteile.

00:48:31.390 --> 00:48:33.370
Dass du halt sozusagen sagst, der State ist

00:48:33.370 --> 00:48:34.890
über alle Instanzen verteilt,

00:48:35.190 --> 00:48:37.570
bleibt über alle Instanzen von diesem Objekt

00:48:37.570 --> 00:48:39.510
gleich und ich muss da nicht kompliziert

00:48:39.510 --> 00:48:41.450
irgendwie dafür sorgen, dass ich immer die gleiche Instanz zurückgebe,

00:48:41.610 --> 00:48:42.710
weil wen interessiert's?

00:48:44.590 --> 00:48:44.950
Ja.

00:48:46.350 --> 00:48:47.670
Ja, aber genau, das sind alles,

00:48:48.330 --> 00:48:49.570
es geht immer so um State Handling

00:48:49.570 --> 00:48:51.270
im Grunde. Das ist immer so das, und

00:48:51.270 --> 00:48:53.370
wer manipuliert den und wie kann man

00:48:53.370 --> 00:48:55.310
dafür sorgen, dass der, dass man

00:48:55.310 --> 00:48:55.810
die,

00:48:56.090 --> 00:48:58.750
den Code, der den State manipuliert,

00:48:58.830 --> 00:49:00.010
an einer Stelle behält und so.

00:49:00.890 --> 00:49:02.730
Weil das sind immer so, das ist was, was halt

00:49:02.730 --> 00:49:04.890
man am Anfang, das ist ein bisschen unintuitiv,

00:49:05.270 --> 00:49:06.910
das denkt man sich so,

00:49:06.990 --> 00:49:08.710
naja, das ist ja kein Problem, State kann

00:49:08.710 --> 00:49:10.950
irgendwo sein, egal, ist in einer Variable,

00:49:11.070 --> 00:49:12.450
in einer globalen Variable oder so, oder

00:49:12.450 --> 00:49:14.790
halt auch oft verteilt

00:49:14.790 --> 00:49:16.250
oder man hat die Klassen,

00:49:16.530 --> 00:49:18.550
sich mal irgendwie überlegt, wie so eine

00:49:18.550 --> 00:49:20.410
Klassenhierarchie aussehen soll oder so, aber

00:49:20.410 --> 00:49:22.590
und zieht das dann durch,

00:49:22.590 --> 00:49:24.350
unabhängig davon, wie das Problem eigentlich ist

00:49:24.350 --> 00:49:26.570
und das fiese,

00:49:26.710 --> 00:49:28.530
was manchmal dann oder fast immer passiert

00:49:28.530 --> 00:49:30.450
irgendwie, ist, dass man dann halt den

00:49:30.450 --> 00:49:32.390
State verteilt über viel Code

00:49:32.390 --> 00:49:33.810
und dass man dann halt... Was ist überhaupt State?

00:49:35.650 --> 00:49:36.450
Das, was ich,

00:49:36.730 --> 00:49:38.210
das, was du speichern musst,

00:49:38.390 --> 00:49:39.550
was sich irgendwie ändert.

00:49:41.130 --> 00:49:42.090
Der Status.

00:49:42.430 --> 00:49:42.570
Ja.

00:49:44.570 --> 00:49:46.370
Also sagen wir mal so, bei einer Web-Applikation

00:49:46.370 --> 00:49:47.950
würde man sagen, das ist der State

00:49:47.950 --> 00:49:50.150
einer Web-Applikation, liegt üblicherweise dann eben

00:49:50.150 --> 00:49:50.810
in der Datenbank.

00:49:52.190 --> 00:49:53.270
Das ist so eine klassische...

00:49:53.270 --> 00:50:15.070
Ja, was bedeutet das? Also was ist denn überhaupt dann der State? Sagt der, wie der Nutzer gerade aussehen soll, wie der heißt und was er für Daten gespeichert hat für sein Profil, was er sehen soll. Und das ist halt nicht dynamisch generiert, sondern das liegt dann irgendwo rum. Das heißt, wenn man das ändern möchte, dann muss man ja erst die Daten anfragen oder sowas. Das macht man dann gar nicht woanders.

00:50:16.550 --> 00:50:17.950
Ja genau, also

00:50:17.950 --> 00:50:19.310
so

00:50:19.310 --> 00:50:23.150
ja, also das, was

00:50:23.150 --> 00:50:23.790
halt sozusagen

00:50:23.790 --> 00:50:26.850
beschreibt, in welchem Zustand deine Applikation ist.

00:50:27.150 --> 00:50:28.390
Gehen wir jetzt nochmal aufs Spiel kurz.

00:50:28.690 --> 00:50:31.010
Was mit der Figur ist. Was hat die gerade

00:50:31.010 --> 00:50:32.910
für eine Waffe in der Hand? Was für Lebensenergie

00:50:32.910 --> 00:50:34.750
hat die? Wie viel Rüstung hat die noch an? Das wäre der State.

00:50:35.110 --> 00:50:37.350
Genau, dann gehst du irgendwo in einen virtuellen

00:50:37.350 --> 00:50:38.730
Laden und kaufst dir irgendwie das

00:50:38.730 --> 00:50:40.810
magische Sonstwas-Schwert, Feuerschwert,

00:50:40.950 --> 00:50:42.230
mit dem du irgendwie alle platt machen kannst.

00:50:42.810 --> 00:50:44.950
Dann muss ja irgendwo gespeichert werden, dass du

00:50:44.950 --> 00:50:46.590
das jetzt hast, dass das eine Adventure ist.

00:50:46.630 --> 00:50:48.790
Und ich darf aber auch keine zwei gleichzeitigen Sachen

00:50:48.790 --> 00:50:50.610
dann irgendwie haben. Also damit das sich jetzt nicht widerspricht,

00:50:50.730 --> 00:50:51.730
darf es immer noch ein State geben.

00:50:52.670 --> 00:50:53.610
Das, was dahinter steckt.

00:50:53.610 --> 00:50:56.210
Die interessante Frage ist, wie verwaltet man diesen

00:50:56.210 --> 00:50:58.310
State sozusagen?

00:50:58.970 --> 00:51:02.230
naiv wäre halt,

00:51:02.710 --> 00:51:04.030
man hat halt zum Beispiel,

00:51:04.110 --> 00:51:06.250
Held ist halt in irgendwelchen globalen Variablen.

00:51:06.430 --> 00:51:08.470
Man hat halt eine Liste, die ist halt

00:51:08.470 --> 00:51:10.510
global und genau, da steht halt

00:51:10.510 --> 00:51:12.310
drin, ja, hier ist halt

00:51:12.310 --> 00:51:14.530
das Flammenschwert und das ist da jetzt

00:51:14.530 --> 00:51:16.490
in dieser Liste der Items drin und

00:51:16.490 --> 00:51:18.310
alle manipulieren diese Liste von Items

00:51:18.310 --> 00:51:20.250
irgendwie, aber das

00:51:20.250 --> 00:51:22.090
macht dann halt Probleme, weil dann

00:51:22.090 --> 00:51:23.710
ist Logik, die jetzt irgendwie

00:51:23.710 --> 00:51:26.190
solche Sachen abbildet, wie

00:51:26.190 --> 00:51:28.330
das Flammenschmerz macht jetzt plus 10

00:51:28.330 --> 00:51:30.510
Angriff, aber auf der anderen Seite

00:51:30.510 --> 00:51:31.330
wird dir heiß, das heißt,

00:51:32.130 --> 00:51:34.150
wird dir die Hand heiß und du verlierst irgendwie

00:51:34.150 --> 00:51:36.310
alle halbe Stunde ein paar Lebenspunkte oder sowas, keine Ahnung.

00:51:38.270 --> 00:51:38.850
Das ist ja

00:51:38.850 --> 00:51:40.070
ein Code, der irgendwie

00:51:40.070 --> 00:51:42.530
diese Business-Logik, wenn man das so sagen kann,

00:51:42.590 --> 00:51:44.410
in dem Spiel halt implementiert

00:51:44.410 --> 00:52:08.670
Und das kann ja sein, dass da unterschiedlicher Code an unterschiedlichen Stellen steht. Und wenn du jetzt überall das gleiche globale Variable hast, auf die du zugreifst, dann musst du dafür sorgen, dass dieser gesamte Code, der halt über dein Projekt verteilt sein kann, dass der immer weiß, was alle anderen Sachen machen. Und das geht ab einer gewissen Größe nicht mehr. Am Anfang geht das, solange es alles sehr klein ist, kriegt man das auch noch hin, dass man das alles im Kopf behält.

00:52:08.670 --> 00:52:23.250
Ja, also du musst halt jedes Mal zumindest diese Überprüfung machen. Du musst halt jedes Mal gucken, hat denn jemand irgendwas geändert an der Stelle, das nicht sein darf. Das heißt, jede dieser Logiken müsstest du bei jeder Stelle, wo diese globale Variable geändert wird, erneut machen, was halt dem Don't Repeat Yourself widerspricht und so.

00:52:24.890 --> 00:52:31.990
Das kann schon durchaus so sein, dass man sich da nicht wiederholt, aber du kannst halt Änderungen machen, die dann nicht lokale Auswirkungen haben.

00:52:33.050 --> 00:52:34.490
Also nehmen wir an, du weißt das halt alles nicht.

00:52:34.650 --> 00:52:41.290
Du machst jetzt halt ein neues Item, das irgendwelche Spezialgeschichten hat, schreibst da Code für, dass das halt irgendwie tut.

00:52:42.390 --> 00:52:47.770
Und dabei bedenkst du aber nicht, dass unter bestimmten Umständen irgendwelcher anderer Code irgendwas anderes tut.

00:52:47.770 --> 00:52:50.550
Und dann passieren halt Fehler und seltsame Effekte.

00:52:51.550 --> 00:52:54.370
Und solange man halt von dem ganzen anderen Code,

00:52:54.390 --> 00:52:57.190
der irgendwie daran rumanipuliert, irgendwie weiß, ist das ja okay.

00:52:57.350 --> 00:52:59.170
Aber sobald das Projekt irgendwie größer wird,

00:52:59.570 --> 00:53:00.370
geht das irgendwann nicht mehr.

00:53:00.550 --> 00:53:03.210
Und dann kann man überhaupt nicht vorhersagen,

00:53:03.290 --> 00:53:06.790
was passieren wird, wenn man jetzt irgendwie Dinge ändert.

00:53:06.970 --> 00:53:09.270
Wie man manipuliert irgendwas an den Lebenspunkten oder so.

00:53:09.390 --> 00:53:10.390
Und dann gibt es irgendwas anderes,

00:53:10.490 --> 00:53:12.150
was wiederum nochmal was anderes macht.

00:53:12.150 --> 00:53:14.250
Der Invincible Geist.

00:53:14.730 --> 00:53:17.650
Ja, und das Mittel dagegen ist halt,

00:53:17.710 --> 00:53:21.910
dass du eben nicht direkt die Daten anfasst,

00:53:21.910 --> 00:53:27.250
sondern dass du sagst, okay, wir haben hier eine Klasse oder so

00:53:27.250 --> 00:53:30.850
und bündeln wir den State, also die Daten,

00:53:31.770 --> 00:53:34.890
und die Logik, die jetzt irgendwas damit macht

00:53:34.890 --> 00:53:39.130
und haben dann eine API nach außen, die öffentlich ist

00:53:39.130 --> 00:53:42.990
und können sozusagen immer überprüfen,

00:53:43.090 --> 00:53:44.470
dass alles ordentlich ist an einer Stelle.

00:53:46.230 --> 00:53:48.170
Ja, die Frage war, was ist ein Objekt

00:53:48.170 --> 00:53:50.210
in Python? Was ist ein Objekt in Python?

00:53:55.890 --> 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.390 --> 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
einer Klasse.

00:54:06.770 --> 00:54:08.630
Also mit einer Klasse

00:54:08.630 --> 00:54:09.510
definiert man sozusagen

00:54:09.510 --> 00:54:14.230
eben eine Zusammenfassung

00:54:14.230 --> 00:54:15.990
von Code, der was tut

00:54:15.990 --> 00:54:17.490
und irgendwie Daten,

00:54:17.870 --> 00:54:19.470
die man irgendwie halten will und

00:54:19.470 --> 00:54:21.730
wenn man das jetzt, das ist halt sozusagen

00:54:21.730 --> 00:54:23.810
die Beschreibung

00:54:23.810 --> 00:54:24.790
und wenn man da jetzt daraus...

00:54:24.790 --> 00:54:26.690
Ich sage nicht so besonders an von dem Brot, der irgendwie

00:54:26.690 --> 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.170
also...

00:54:33.170 --> 00:54:35.570
Also ein Objekt 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. Ein Objekt ist immer

00:54:41.250 --> 00:54:42.870
eine Instanz einer Klasse,

00:54:43.410 --> 00:54:44.150
wenn man das so sagt. Ja.

00:54:44.890 --> 00:54:46.610
Das heißt, alles, was ihr habt

00:54:46.610 --> 00:54:48.590
in Python, sind tatsächlich Instanzen von irgendwelchen

00:54:48.590 --> 00:54:49.530
Klassen, von irgendwelchen Dingen.

00:54:50.850 --> 00:54:52.430
Die nächste Frage war, was ist Self?

00:54:52.710 --> 00:54:54.270
Self ist immer das Objekt selbst.

00:54:54.590 --> 00:54:55.930
Ja, es ist auch eine

00:54:55.930 --> 00:54:58.390
Konvention, dass man das so nennt, aber

00:54:58.390 --> 00:55:00.610
sehr sinnvoll,

00:55:00.710 --> 00:55:02.470
das so zu machen. Außer es gibt

00:55:02.470 --> 00:55:04.390
wiederum Spezialfälle, bei denen man das ein bisschen anders macht.

00:55:04.590 --> 00:55:05.290
Also wenn man

00:55:05.290 --> 00:55:08.550
eine Methode

00:55:08.550 --> 00:55:10.330
hat, also Methode ist nichts weiter als eine

00:55:10.330 --> 00:55:12.250
Funktion, die sozusagen

00:55:12.250 --> 00:55:14.390
an so eine

00:55:14.890 --> 00:55:16.790
Instanz an so ein Objekt gebunden

00:55:16.790 --> 00:55:18.630
ist. Und

00:55:18.630 --> 00:55:20.610
jetzt möchte man halt, um

00:55:20.610 --> 00:55:22.550
zum Beispiel auf die Daten, die man halten möchte, in so

00:55:22.550 --> 00:55:24.630
einem Objekt, um da drauf

00:55:24.630 --> 00:55:26.730
zuzugreifen, muss man ja irgendwie sich selbst referenzieren

00:55:26.730 --> 00:55:28.830
können. Deswegen wird immer als erstes Argument

00:55:28.830 --> 00:55:29.690
in Methoden,

00:55:30.490 --> 00:55:32.810
das ist halt auch das, was dann Methoden von Funktionen

00:55:32.810 --> 00:55:34.210
unterscheidet, immer

00:55:34.210 --> 00:55:35.650
eine Referenz auf

00:55:35.650 --> 00:55:38.190
sich selbst

00:55:38.190 --> 00:55:40.530
sozusagen mit übergeben. Man könnte das auch

00:55:40.530 --> 00:55:42.230
anders nennen. Man kann auch sagen,

00:55:43.550 --> 00:55:44.570
A statt self, dann

00:55:44.570 --> 00:55:46.470
ist es A, aber es ist schon sinnvoll,

00:55:46.530 --> 00:55:48.030
das Self zu nennen, damit man weiß, dass es halt eine

00:55:48.030 --> 00:55:50.410
Referenz auf sich selbst ist, sozusagen

00:55:50.410 --> 00:55:52.450
auf das Objekt, was gerade, was man

00:55:52.450 --> 00:55:54.170
gerade ist. Und dann kann man halt auf

00:55:54.170 --> 00:55:56.070
Self-Punkt irgendwelche Daten zugreifen.

00:55:57.230 --> 00:55:58.450
Da fangen wir jetzt direkt ein paar andere

00:55:58.450 --> 00:56:00.410
Sachen ein, weil wir jetzt gerade so hatten mit Objekt.

00:56:00.590 --> 00:56:02.290
Was ist denn ein Objekt? Es ist eine Klasse und

00:56:02.290 --> 00:56:04.010
jetzt gibt es irgendwie drei Dekoratoren.

00:56:04.210 --> 00:56:06.390
Wir müssen auch gleich darüber sprechen, was ein Dekorator ist.

00:56:06.730 --> 00:56:08.290
Aber es gibt drei Dekoratoren, die

00:56:08.290 --> 00:56:10.370
Python verwendet, die da

00:56:10.370 --> 00:56:12.510
immer so drüber stehen. Das StaticMessage,

00:56:12.570 --> 00:56:13.770
ClassMessage und

00:56:13.770 --> 00:56:16.210
Property, über Property

00:56:16.210 --> 00:56:18.130
hattest du eben auch schon. Was ist denn

00:56:18.130 --> 00:56:19.790
jetzt da irgendwie so der kleine

00:56:19.790 --> 00:56:22.270
Haken? Also wann dachte man jetzt zum Beispiel,

00:56:22.370 --> 00:56:24.110
das ist eine statische Methode und

00:56:24.110 --> 00:56:26.030
wann dachte man, das ist eine Klassenmethode? Was heißt

00:56:26.030 --> 00:56:27.910
das denn in dem Kontext zu Self und Objekt

00:56:27.910 --> 00:56:30.210
und... Ja, also

00:56:30.210 --> 00:56:32.310
ich würde eigentlich am liebsten

00:56:32.310 --> 00:56:34.010
mit der Klassenmethode

00:56:34.010 --> 00:56:35.830
anfangen. Also... Class Method.

00:56:35.890 --> 00:56:37.750
Class Method ist

00:56:37.750 --> 00:56:39.170
halt eine

00:56:39.170 --> 00:56:42.110
Methode, die

00:56:42.110 --> 00:56:43.870
eben nicht eine konkrete Instanz.

00:56:44.650 --> 00:56:46.010
Das heißt, da fehlt auch Self bei.

00:56:46.150 --> 00:56:48.110
Genau, da könnte man jetzt auch Self

00:56:48.110 --> 00:56:49.410
übergeben, das wäre dann sehr verwirrend.

00:56:50.090 --> 00:56:52.090
Sondern was man da üblicherweise übergibt

00:56:52.090 --> 00:56:53.950
ist ein CLS oder so

00:56:53.950 --> 00:56:55.310
und bekommt man die Klasse übergeben.

00:56:55.610 --> 00:56:56.710
Die Klasse ist auch wieder ein Objekt.

00:56:58.290 --> 00:56:59.870
Man kann das dann auch ein Stückchen weiter treiben,

00:56:59.930 --> 00:57:01.110
auch dann mit dem Meta-Klassenanschluss.

00:57:02.050 --> 00:57:03.910
Also das kleinste Objekt, also jede Klasse

00:57:03.910 --> 00:57:06.030
ist irgendwie ein Objekt und das Objekt-Objekt-Objekt

00:57:06.030 --> 00:57:08.230
selber ist ein Objekt vom Typ-Typ.

00:57:08.710 --> 00:57:09.370
Ja, okay.

00:57:10.390 --> 00:57:11.030
Ja, okay.

00:57:11.690 --> 00:57:27.030
Ja, also jedenfalls in der Klassenmethode übergibt man halt CLS und nicht Self, weil man damit halt weiß, dass man jetzt gerade die Klasse in der Hand hat und nicht eine Referenz auf die Instanz.

00:57:28.350 --> 00:57:38.090
Und es gibt halt, das verwendet man vor allen Dingen dafür, dass man, es gibt halt bestimmte Methoden, die brauchen eben nicht, die müssen nicht auf irgendwelche internen Daten oder so zugreifen, weil die hat man ja nicht.

00:57:39.190 --> 00:57:47.510
Sondern die gehören zwar vielleicht irgendwie in die Klasse rein, weil die Funktionalität, die sie bieten, halt sehr viel zu tun hat mit der Klasse.

00:57:48.210 --> 00:57:52.790
Aber die verhalten sich in gewisser Weise natürlich dann so wie eine normale Funktion.

00:57:54.190 --> 00:58:00.690
Und vielleicht können sie auch auf Daten, die halt für alle Instanzen dieser Klasse gleich sind, zugreifen eben über die Klasse.

00:58:00.690 --> 00:58:08.510
Aber die brauchen jetzt nicht irgendwie eine konkrete Instanz, auf der sie irgendwas machen.

00:58:08.630 --> 00:58:09.490
Also ein Beispiel für

00:58:09.490 --> 00:58:12.510
sowas sind, was ist denn

00:58:12.510 --> 00:58:13.590
ein gutes Beispiel für?

00:58:19.590 --> 00:58:20.890
Jetzt bin ich schon aus dem Spiel.

00:58:21.310 --> 00:58:22.690
Also zwei Beispiele, die ich ganz

00:58:22.690 --> 00:58:24.830
gut zu visualisieren finde. Entweder hat man

00:58:24.830 --> 00:58:26.310
so ein Spiel mit so Charakteren

00:58:26.310 --> 00:58:28.790
oder man hat so ein Universum mit Planeten

00:58:28.790 --> 00:58:30.630
und Dingen, die umeinander kreisen oder sowas.

00:58:31.190 --> 00:58:32.630
Zwei verschiedene Sonnensysteme als

00:58:32.630 --> 00:58:34.930
zwei Klassen. Okay, lass mir das.

00:58:35.430 --> 00:58:36.770
Ich weiß nicht so genau, ob ich das da

00:58:36.770 --> 00:58:37.590
irgendwie, also

00:58:37.590 --> 00:58:44.730
mir fällt da jetzt gar nichts, also

00:58:44.730 --> 00:58:47.370
es sind oft irgendwelche Hilfsfunktionen

00:58:47.370 --> 00:58:49.210
oder so, die was machen,

00:58:49.310 --> 00:58:51.190
was logisch dann in der Klasse gehört, aber

00:58:51.190 --> 00:58:53.230
wo man nicht mit einer konkreten Instanz irgendwas zu tun

00:58:53.230 --> 00:58:55.030
hat. Mir fällt jetzt tatsächlich

00:58:55.030 --> 00:58:56.470
kein super tolles Beispiel

00:58:56.470 --> 00:58:59.050
ein. Was ist denn der beste und fließende Static Method?

00:58:59.150 --> 00:59:00.350
Was wäre das denn jetzt so als?

00:59:01.250 --> 00:59:02.590
Ja, Static Method.

00:59:06.150 --> 00:59:07.170
Die bekommt halt

00:59:07.170 --> 00:59:08.790
einfach 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:16.250
Das heißt, sie könnte man auch draußen hinschreiben.

00:59:16.970 --> 00:59:17.210
Genau.

00:59:17.570 --> 00:59:19.070
Der einzige Unterschied bei der Static-Method ist halt,

00:59:19.130 --> 00:59:21.430
dass sie dann 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.170
Ja, was ist jetzt in dem Vergleich eine Static-Method?

00:59:31.890 --> 00:59:32.130
Okay.

00:59:33.870 --> 00:59:35.370
Ja, also Static-Method

00:59:35.370 --> 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
Also 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:51.930
eine Funktion

00:59:51.930 --> 00:59:53.550
von draußen, genau.

00:59:54.250 --> 00:59:55.490
Ah, richtig, jetzt

00:59:55.490 --> 00:59:57.530
fällt 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.270
eine Zeile, also wenn ich jetzt zum Beispiel

01:00:36.270 --> 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.610 --> 01:00:58.810
Auf allen Nutzern. Ja, genau, auf allen

01:00:58.810 --> 01:01:00.770
Nutzern oder ich möchte einen neuen Nutzer erzeugen.

01:01:01.570 --> 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.710
sag ich dann

01:01:07.710 --> 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.270 --> 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, das mit dem Manager lassen wir jetzt mal kurz

01:01:28.850 --> 01:01:30.590
weg, da müssen wir uns schon ein bisschen langgucken. 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:36.990
und

01:01:36.990 --> 01:01:42.530
ja, was halt sozusagen

01:01:42.530 --> 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
ranzählen würde, gar nicht so richtig funktioniert. Ja, könnte man auch machen,

01:01:56.590 --> 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.230
was sind denn jetzt die ganzen Felder.

01:02:10.250 --> 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.850 --> 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.710 --> 01:02:29.570
Das könnte ich dann vielleicht gucken.

01:02:29.670 --> 01:02:31.790
Static Method könnte sowas sein, wie hash mir mal das

01:02:31.790 --> 01:02:33.910
Passwort. Also hier hast du einen String,

01:02:34.110 --> 01:02:36.070
mach mir mal einen Hash davon, den ich dann irgendwie in die Datenbank

01:02:36.070 --> 01:02:37.830
schreibe. Das braucht

01:02:37.830 --> 01:02:39.710
gar keinen Kontext. Das nimmt irgendwie einen String

01:02:39.710 --> 01:02:41.870
und gibt einen anderen String raus. Das braucht aber sonst

01:02:41.870 --> 01:02:43.010
überhaupt nichts zu wissen.

01:02:43.870 --> 01:02:45.850
Und das könnte dann ein Static Method sein, zum Beispiel.

01:02:46.130 --> 01:02:47.910
Aber es gehört halt logisch vielleicht schon in die

01:02:47.910 --> 01:02:49.790
User-Klasse, weil es halt irgendwie um

01:02:49.790 --> 01:02:51.830
Passwörter geht, die ein User

01:02:51.830 --> 01:02:53.510
eingibt und die dann halt irgendwie gehashed werden sollen.

01:02:54.050 --> 01:02:55.570
Also das könnte man... Jetzt haben wir noch Property.

01:02:56.650 --> 01:02:57.750
Property-Dekorator, ja.

01:02:57.830 --> 01:03:14.990
Und da geht es eigentlich nur darum, dass man, ja, so ein bisschen Convenience, dass man nicht eine Methode aufruft, sondern, also man schreibt halt, also der häufigste Fall ist, man hat eine Methode, die nennt man so wie ein Attribut und schreibt dann AddProperty drüber.

01:03:16.010 --> 01:03:21.630
Und dann wird halt diese Methode aufgerufen, wenn man irgendwo sagt Instanz.Fubar.

01:03:21.630 --> 01:03:23.750
Also braucht man eigentlich nicht, man könnte auch eine Methode schreiben.

01:03:24.650 --> 01:03:26.630
Ja, aber dann müsste man halt dann an der Stelle, wo man

01:03:26.630 --> 01:03:28.690
es 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.570
aber wo man Sachen noch ausrechnen will und

01:03:40.570 --> 01:03:42.750
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:54.610
ist so manchmal ein bisschen...

01:03:54.650 --> 01:03:57.290
also auf Python steht ja sowas

01:03:57.290 --> 01:03:59.350
explizites besser als implizit und das ist halt

01:03:59.350 --> 01:04:01.430
schon ganz schön implizit, dass wenn man

01:04:01.430 --> 01:04:02.430
jetzt irgendwo

01:04:02.430 --> 01:04:05.450
eben Instanz

01:04:05.450 --> 01:04:07.510
x.huber sagt

01:04:07.510 --> 01:04:09.350
halt dann irgendwie Code ausgeführt wird,

01:04:09.410 --> 01:04:11.350
der irgendwas ausrechnet und dann unter Umständen auch sehr langsam

01:04:11.350 --> 01:04:12.970
sein kann oder was auch immer, das ist halt nicht unbedingt,

01:04:13.190 --> 01:04:14.950
also in dem Moment, wo man das halt lokal liest,

01:04:16.130 --> 01:04:17.350
weiß man nicht, was passiert,

01:04:17.350 --> 01:04:19.070
was immer so ein bisschen schlecht ist, aber

01:04:19.070 --> 01:04:21.370
ja, es ist

01:04:21.370 --> 01:04:23.190
eigentlich normalerweise, wenn man dann

01:04:23.190 --> 01:04:24.910
komplizierte Sachen macht, dann sollte man das

01:04:24.910 --> 01:04:26.570
vielleicht dann auch eher als Methode hinschreiben

01:04:26.570 --> 01:04:28.870
und dann wird das dann vielleicht

01:04:28.870 --> 01:04:30.650
klarer. Aber wenn man kurz vielleicht

01:04:30.650 --> 01:04:32.770
zwei Attribute hat, wie das eine ist

01:04:32.770 --> 01:04:34.610
Kosten, das andere ist Umsatz

01:04:34.610 --> 01:04:36.750
und dann will man den Gewinn ausrechnen, dann kann man

01:04:36.750 --> 01:04:38.690
vielleicht schon eine Funktion machen, die dann einfach kurz

01:04:38.690 --> 01:04:40.530
als Property sagt, hier

01:04:40.530 --> 01:04:42.550
Umsatz gewinnen und dann

01:04:42.550 --> 01:04:43.490
geht das einfach schnell aus.

01:04:44.330 --> 01:04:46.870
Also das

01:04:46.870 --> 01:04:48.750
Get zu implementieren ist sehr, sehr leicht.

01:04:48.830 --> 01:04:50.350
Man schreibt irgendwie der Property drüber und dann war's das.

01:04:50.790 --> 01:04:52.330
Das Set geht auch, also man kann

01:04:52.330 --> 01:04:54.330
das auch so machen, dass dann halt ein Setter aufgerufen wird,

01:04:54.410 --> 01:04:56.710
wenn man sagt, irgendwas, InstanceX.fuba

01:04:56.710 --> 01:04:57.490
gleich irgendwie.

01:04:58.290 --> 01:05:00.130
Das ist ein bisschen komplizierter, aber

01:05:00.130 --> 01:05:01.790
ja, geht auch so ähnlich.

01:05:03.630 --> 01:05:04.370
Ja, also

01:05:04.370 --> 01:05:06.490
man kann, ich weiß nicht genau, man kann mit dem Property-Dekorator

01:05:06.490 --> 01:05:08.390
irgendwie sagen, so, das ist hier der Getter, das ist hier

01:05:08.390 --> 01:05:09.930
der Setter oder was, ich weiß nicht genau.

01:05:10.270 --> 01:05:11.470
Kann man dann nachgucken, wie man es braucht. Braucht man

01:05:11.470 --> 01:05:14.310
selten. Also ich habe es ein paar Mal benutzt,

01:05:14.310 --> 01:05:15.130
aber nicht oft.

01:05:16.390 --> 01:05:18.590
Aber überhaupt das Konzept von Dekoratoren.

01:05:18.610 --> 01:05:20.230
Das ist mal ganz gut. Getter-Setter bedeutet halt, dass

01:05:20.230 --> 01:05:21.890
mal die Attribute irgendwie von außen dann

01:05:21.890 --> 01:05:23.530
beeinflussen, setzen. Von einer Instanz

01:05:23.530 --> 01:05:26.110
bekommt oder setzt

01:05:26.110 --> 01:05:27.950
und zwar nicht direkt

01:05:27.950 --> 01:05:28.910
manipuliert, sondern

01:05:28.910 --> 01:05:31.950
Methoden dafür aufruft, die dann noch

01:05:31.950 --> 01:05:34.070
irgendwas vorher und hinterher tun. Jetzt haben wir schon ungefähr 50 Mal

01:05:34.070 --> 01:05:35.910
Dekorator gesagt und du wolltest eigentlich noch irgendwas anderes

01:05:35.910 --> 01:05:37.890
vorher sagen. Dann muss man vielleicht nochmal erklären, was

01:05:37.890 --> 01:05:39.830
Dekorator eigentlich ist. Eigentlich ist es

01:05:39.830 --> 01:05:42.550
eine sehr, eigentlich nicht so

01:05:42.550 --> 01:05:45.790
es kann leicht

01:05:45.790 --> 01:05:46.510
kompliziert werden.

01:05:48.710 --> 01:05:50.010
Ja, es ist auf der einen Seite ein bisschen

01:05:50.010 --> 01:05:51.170
Spezialsyntax.

01:05:52.390 --> 01:05:54.130
Diese Geschichte mit dem Ad-Symbol, dass man halt

01:05:54.130 --> 01:05:55.150
über Klassen und über

01:05:55.150 --> 01:05:57.790
Methoden, Funktionen schreiben kann.

01:05:58.670 --> 01:06:00.310
Auf der anderen Seite ist es,

01:06:01.010 --> 01:06:02.230
man könnte es auch anders hinschreiben.

01:06:02.850 --> 01:06:04.150
Da bräuchte man diese Spezialsyntax

01:06:04.150 --> 01:06:05.390
nicht, also die haben das so ein bisschen

01:06:05.390 --> 01:06:07.610
vereinfacht. Man könnte halt auch hinschreiben

01:06:07.610 --> 01:06:10.390
irgendwie x gleich

01:06:10.390 --> 01:06:13.770
wrap mir mal eine andere Funktion,

01:06:13.770 --> 01:06:15.730
wrap, Klammer auf, irgendwie eine andere Funktion,

01:06:15.850 --> 01:06:17.790
Klammer zu. Und dann wäre das

01:06:17.790 --> 01:06:19.630
die dekorierte, wäre x die dekorierte Funktion.

01:06:19.890 --> 01:06:22.450
Und man macht sich eine Tapete auf die Wand

01:06:22.450 --> 01:06:24.770
und unter der sieht man halt hier Sachen anders.

01:06:25.750 --> 01:06:26.610
Ah, die Form bleibt erhalten,

01:06:26.690 --> 01:06:27.950
aber die ist dann vielleicht rot oder blau.

01:06:28.630 --> 01:06:30.390
Ja, also die Idee ist sozusagen,

01:06:30.530 --> 01:06:31.070
dass man

01:06:31.070 --> 01:06:36.630
etwas macht, also man halt Code hat,

01:06:37.130 --> 01:06:38.750
der, ja man

01:06:38.750 --> 01:06:40.530
packt, deswegen ist Dekorator eigentlich

01:06:40.530 --> 01:06:42.530
auch ein, der zeichnet ziemlich genau, was es tut.

01:06:44.130 --> 01:06:44.430
Man hat halt...

01:06:44.430 --> 01:06:46.430
Input und Output, der rauskommt oder beziehungsweise

01:06:46.430 --> 01:06:47.570
reingeht, wird...

01:06:47.570 --> 01:06:49.730
geht nochmal durch anderen Code durch und

01:06:49.730 --> 01:06:50.210
dann

01:06:50.210 --> 01:06:53.170
sozusagen man kann halt, bevor

01:06:53.170 --> 01:06:55.750
die Funktion aufgerufen wird, irgendwie Dinge damit

01:06:55.750 --> 01:06:57.910
tun und hinterher

01:06:57.910 --> 01:06:59.910
Dinge mit dem... Das wird aber ganz schön langsam,

01:06:59.990 --> 01:07:01.770
wenn das durch einen Dekorator hat, der einen Dekorator hat,

01:07:01.810 --> 01:07:03.510
der einen Dekorator hat, dann...

01:07:03.510 --> 01:07:05.670
Ja, aber normale Funktionsaufrufe

01:07:05.670 --> 01:07:07.650
macht man ja auch, ist auch

01:07:07.650 --> 01:07:09.690
okay, also das ist ja auch nichts anderes

01:07:09.690 --> 01:07:11.730
im Grunde. Das heißt, wenn man einen Dekorator selber schreibt,

01:07:11.830 --> 01:07:13.530
dann baut man quasi einen eigenen Rapper und sagt halt, was

01:07:13.530 --> 01:07:15.550
passiert, bevor der da reingeht und wann der wieder rauskommt.

01:07:16.670 --> 01:07:23.550
Ja, man sollte auch tatsächlich, genau, nicht wirklich, wenn man Dekoratoren schreibt,

01:07:23.670 --> 01:07:28.350
nicht das selber machen eigentlich, sondern man sollte für den Functools Reps oder so nehmen.

01:07:29.290 --> 01:07:34.210
Und weil es gibt noch so ein paar Hakeligkeiten mit den Funktionsnamen zum Beispiel,

01:07:34.330 --> 01:07:37.250
die sonst verschwinden, wenn man, die sieht man in Tracebacks nicht mehr

01:07:37.250 --> 01:07:41.190
und da muss man so ein bisschen, und dann gibt es halt eben in den Functools,

01:07:41.190 --> 01:07:43.450
gibt es da, glaube ich, irgendwie

01:07:43.450 --> 01:07:46.190
Funktionen,

01:07:46.250 --> 01:07:47.850
die, wenn man die benutzt, um den Rekord-Dekorator

01:07:47.850 --> 01:07:49.470
zu bauen, dann kümmern die sich um diesen Kram,

01:07:49.590 --> 01:07:51.710
sodass halt dann man in Traceworks weiterhin die Namen sieht und so.

01:07:51.790 --> 01:07:53.670
Also das ist ein bisschen... Was hat denn das jetzt mit so einem Kontext

01:07:53.670 --> 01:07:55.550
zu tun? Kontextmanager oder sowas? Oh, nee.

01:07:55.790 --> 01:07:57.550
Das hat aber nichts zu tun. Das ist eine andere Geschichte.

01:07:58.530 --> 01:07:59.650
Das hört er sich so ein bisschen an, als

01:07:59.650 --> 01:08:01.470
macht man irgendwie so einen Kontext auf und rappt irgendwas und

01:08:01.470 --> 01:08:03.430
baut das dann am Ende wieder auseinander.

01:08:05.850 --> 01:08:06.630
Hm, also

01:08:06.630 --> 01:08:09.390
ja, also was

01:08:09.390 --> 01:08:10.630
eventuell irgendwie

01:08:10.630 --> 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
Closures verwendet, wie das

01:08:17.210 --> 01:08:18.210
umgesetzt ist, aber

01:08:18.210 --> 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:26.990 --> 01:08:27.650
Und die halt,

01:08:27.730 --> 01:08:29.090
das ist ja auch so der Trick, wie man das hinkriegt,

01:08:29.190 --> 01:08:30.490
dass der Scope,

01:08:30.770 --> 01:08:33.270
dass man halt auf die Sachen zugreifen kann,

01:08:33.530 --> 01:08:34.770
die im Scope der Funktion sind,

01:08:35.310 --> 01:08:36.230
dass man halt sozusagen,

01:08:38.270 --> 01:08:39.430
naja, das ist zu kompliziert,

01:08:39.530 --> 01:08:41.190
das kann man alles nicht so, das ist auch nicht entfängermäßig,

01:08:41.230 --> 01:08:43.350
das kann man nicht gut erklären. Da muss man sich einfach mal,

01:08:43.710 --> 01:08:44.830
also ich würde sagen, ein Tipp ist,

01:08:46.150 --> 01:08:47.490
wenn man Dekoratoren schreiben

01:08:47.490 --> 01:08:49.070
will, aus den Funktools

01:08:49.070 --> 01:08:51.550
die Wraps-Funktion zu nehmen

01:08:51.550 --> 01:08:52.310
und

01:08:52.310 --> 01:08:55.530
einfach mal so ein bisschen damit rumzuspielen.

01:08:55.630 --> 01:08:57.130
Man braucht ein bisschen, bis das irgendwie,

01:08:58.030 --> 01:08:58.970
bis man das so raus hat.

01:09:00.230 --> 01:09:00.370
Ja.

01:09:02.430 --> 01:09:03.770
Genau, aber dafür sind Dekoratoren

01:09:03.770 --> 01:09:05.570
da. Man kann damit ganz nette

01:09:05.570 --> 01:09:06.770
Sachen machen, wie zum Beispiel,

01:09:07.810 --> 01:09:09.470
also wenn man einfach nur wissen will, wofür braucht man

01:09:09.470 --> 01:09:11.790
solche Sachen eigentlich, wenn man

01:09:11.790 --> 01:09:13.530
zum Beispiel eben

01:09:13.530 --> 01:09:15.370
wie der Datenbankgeschichte, kann man sagen,

01:09:15.530 --> 01:09:17.750
okay, gibt es einen Transaktions-Dekorator.

01:09:17.950 --> 01:09:19.170
Da schreibt man einfach drüber.

01:09:19.990 --> 01:09:21.470
Transaction Atomic. Genau.

01:09:22.370 --> 01:09:23.490
Das hier ist jetzt alles in

01:09:23.490 --> 01:09:25.350
einer Transaktion und alle Schritte gehen

01:09:25.350 --> 01:09:27.110
zusammen gut oder gar nicht. Und wenn halt

01:09:27.110 --> 01:09:29.150
zwischendurch irgendwas nicht

01:09:29.150 --> 01:09:31.230
funktioniert hat, dann rollt das automatisch

01:09:31.230 --> 01:09:33.130
die Datenbank in den ursprünglichen Zustand zurück, als wäre

01:09:33.130 --> 01:09:35.190
nichts passiert. Das ist ein tolles Beispiel, weil da gibt es nämlich auch

01:09:35.190 --> 01:09:37.210
den Kontextmanager. Man kann auch sagen, with a Transaction

01:09:37.210 --> 01:09:38.330
Atomic. Ja, ja, ja, genau.

01:09:38.530 --> 01:09:40.470
Ja, es ist, klar, kann man auch

01:09:40.470 --> 01:09:41.010
machen, ja.

01:09:43.850 --> 01:09:44.170
Ja.

01:09:46.830 --> 01:09:48.370
Das, genau, das ist eine

01:09:48.370 --> 01:09:49.550
Geschichte. Ansonsten,

01:09:50.850 --> 01:09:52.590
ja, man kann auch Dekoratoren dafür benutzen,

01:09:52.710 --> 01:09:54.370
um sich jetzt eine bestimmte Datenbankverwendung

01:09:54.370 --> 01:09:56.450
immer reinzuholen in eine Funktion.

01:09:56.650 --> 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.650 --> 01:10:02.350
Login Required, dass man halt irgendwie eingeloggter

01:10:02.350 --> 01:10:03.830
Benutzer sein muss. Das heißt,

01:10:04.010 --> 01:10:06.370
die Frage ist halt, was er dann macht. Das kann man

01:10:06.370 --> 01:10:08.410
auch als Mix-In benutzen, das heißt, auch das

01:10:08.410 --> 01:10:10.430
wäre eine ähnliche Methode. Ein Mixin

01:10:10.430 --> 01:10:12.270
ist eine Subklasse,

01:10:12.450 --> 01:10:14.230
eine Klasse, die man benutzt, um bestimmte

01:10:14.230 --> 01:10:16.410
Attribute zusätzlich... Mixin sind so ein bisschen

01:10:16.410 --> 01:10:17.510
eben, wie man

01:10:17.510 --> 01:10:19.910
Code

01:10:19.910 --> 01:10:22.190
wiederverwenden kann in

01:10:22.190 --> 01:10:24.250
Klassen, ohne erben zu müssen. Weil erben

01:10:24.250 --> 01:10:26.450
macht natürlich, das ist ja sozusagen ein ganz klassischer

01:10:26.450 --> 01:10:28.190
Weg und das kann man natürlich auch tun. Ja, also in gewisser Weise

01:10:28.190 --> 01:10:30.150
ist es ja eine Form von vererben, aber eine generalisierte

01:10:30.150 --> 01:10:32.010
Form, die irgendwie jetzt nicht genau mit der

01:10:32.010 --> 01:10:33.950
ursprünglichen Klasse zu tun hat, sondern...

01:10:33.950 --> 01:10:35.950
Ja, genau. Also du kannst halt, ist es nicht so, dass

01:10:35.950 --> 01:10:38.310
du, ja, also zwei unterschiedliche

01:10:38.310 --> 01:10:40.230
Klassen, die nichts miteinander zu tun haben, ganz unterschiedliche

01:10:40.230 --> 01:10:42.270
Stellen in der Klassengereiche sind,

01:10:42.390 --> 01:10:43.910
können halt das gleiche Mix-In verwenden.

01:10:44.330 --> 01:10:46.210
Cool, das ist so ein bisschen wie Genetik. Du kannst

01:10:46.210 --> 01:10:47.670
dem Frosch Flügel geben oder so.

01:10:48.870 --> 01:10:49.110
Ja.

01:10:50.570 --> 01:10:51.730
Das ist, äh,

01:10:52.210 --> 01:10:53.850
ja, ja, warum auch nicht?

01:10:56.010 --> 01:10:56.370
Ja, wenn

01:10:56.370 --> 01:10:58.090
man sagt, man hat die Flügel haben wollen, man hat irgendwie eine

01:10:58.090 --> 01:11:00.210
Klasse, die Flügel bereitstellt, dann kann man diese Flügel

01:11:00.210 --> 01:11:01.310
jeder Klasse geben und jetzt.

01:11:01.310 --> 01:11:02.890
Ja, macht natürlich

01:11:02.890 --> 01:11:04.690
auch nicht immer irgendwie Sinn, aber

01:11:04.690 --> 01:11:06.550
also, also

01:11:06.550 --> 01:11:08.710
Vererbung ist auch so ein problematisches

01:11:08.710 --> 01:11:10.410
Gefühl. Das ist immer das, was einem, wenn man

01:11:10.410 --> 01:11:12.530
sich mit objektorientierter Programmierung beschäftigt,

01:11:12.610 --> 01:11:14.570
irgendwie so gesagt wird, wie man das tun soll oder so am Anfang.

01:11:14.670 --> 01:11:16.470
Keine Ahnung, jedenfalls bei mir ist es mittlerweile auch besser

01:11:16.470 --> 01:11:18.410
geworden, dass man halt

01:11:18.410 --> 01:11:20.390
Sachen von Dingen dann erbt, dass man halt

01:11:20.390 --> 01:11:22.070
keine Ahnung,

01:11:24.150 --> 01:11:24.370
ja,

01:11:24.650 --> 01:11:26.230
weiß ich nicht, da wird immer mit solchen

01:11:26.230 --> 01:11:28.050
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, ne? 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, ne? Und ein Dreieck

01:11:42.030 --> 01:11:43.270
ist irgendwas, was halt irgendwie...

01:11:43.270 --> 01:11:45.110
Ja, ich finde das gar nicht so schlecht, das nämlich dem Gradius

01:11:45.110 --> 01:11:46.810
auch vorzustellen, ne? Also die Geometrische Formen sind

01:11:46.810 --> 01:11:49.050
ganz okay, aber

01:11:49.050 --> 01:11:50.150
vielleicht auch mit dieser

01:11:50.150 --> 01:11:53.150
Universumsgeschichte. Du hast irgendwo

01:11:53.150 --> 01:11:55.070
ein großes schwarzes Loch, so

01:11:55.070 --> 01:11:57.010
den Urknall oder sowas, und ein Objekt

01:11:57.010 --> 01:11:59.130
orbitet da irgendwie herum. Das ist

01:11:59.130 --> 01:12:00.630
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.850 --> 01:13:13.850
Also Mond, Vermieter, Planet.

01:13:16.150 --> 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.450 --> 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 Mixin 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:53.810
und hinterher gut anpassen.

01:14:53.910 --> 01:14:55.090
Es geht alles nicht so richtig schön.

01:14:55.590 --> 01:14:57.690
Und am Anfang zu sehen, wie das richtig wäre

01:14:57.690 --> 01:14:59.030
für das Problem, was man eigentlich lösen will,

01:14:59.050 --> 01:15:00.010
ist sehr schwer.

01:15:00.170 --> 01:15:01.510
Ja, weil man das Problem meistens gar nicht genau kennt.

01:15:01.510 --> 01:15:03.070
Genau, man kennt meistens das Problem nicht richtig.

01:15:03.610 --> 01:15:05.230
Und bei Mixins ist es relativ simpel.

01:15:05.330 --> 01:15:06.790
Das ist halt so wie, keine Ahnung,

01:15:06.870 --> 01:15:10.030
wenn ich ohne Objektorientierung programmiere,

01:15:10.090 --> 01:15:12.730
dann habe ich halt Funktionen, die ich aufrufe.

01:15:13.190 --> 01:15:14.490
Und wenn ich jetzt merke,

01:15:14.490 --> 01:15:17.350
ich benutze den gleichen Code an drei, vier unterschiedlichen Stellen,

01:15:17.870 --> 01:15:20.270
dann mache ich halt

01:15:20.270 --> 01:15:22.130
eine Funktion draus und rufe den

01:15:22.130 --> 01:15:24.090
an den Stellen, wo ich sozusagen

01:15:24.090 --> 01:15:26.190
das verwenden möchte, den Code einfach

01:15:26.190 --> 01:15:27.910
auf, anstelle, dass ich den Code

01:15:27.910 --> 01:15:29.990
daraus entstehen habe. Und genauso kann man das mit

01:15:29.990 --> 01:15:32.030
Klassen im Grunde auch machen und Code,

01:15:32.090 --> 01:15:34.070
den ich in mehreren Klassen benutze, den ziehe ich halt in Mixins

01:15:34.070 --> 01:15:35.890
raus. Und dann

01:15:35.890 --> 01:15:37.350
ist es relativ easy, weil

01:15:37.350 --> 01:15:38.290
ja,

01:15:39.710 --> 01:15:42.010
diese Mixins machen halt nichts anderes, außer

01:15:42.010 --> 01:15:43.670
irgendwie halt eine Methode sozusagen

01:15:43.670 --> 01:15:45.050
hinzuzufügen zu einer Klasse.

01:15:46.150 --> 01:15:47.590
Und ja,

01:15:47.870 --> 01:15:50.530
ja und so

01:15:50.530 --> 01:15:51.150
Vererbungen,

01:15:51.350 --> 01:15:54.230
das macht halt mehr.

01:15:55.250 --> 01:15:56.610
Das tut mehr, also es gibt halt

01:15:56.610 --> 01:15:58.290
diese Basis, Basisklassen,

01:15:58.410 --> 01:16:00.150
Basis oder sowas, da gibt es noch sowas wie

01:16:00.150 --> 01:16:02.550
Message Resolution Order, MROs,

01:16:02.610 --> 01:16:04.710
wo man dann gucken kann, welche Methoden in welcher Reihenfolge

01:16:04.710 --> 01:16:06.530
aufrufen werden, weil die sich ja gegenseitig überschreiben

01:16:06.530 --> 01:16:08.550
können und das Problem, was man

01:16:08.550 --> 01:16:10.470
dann hat irgendwann ist, dass wenn man da, wie du sagst,

01:16:10.510 --> 01:16:12.270
einen Fehler macht, dann hat man

01:16:12.270 --> 01:16:14.210
Circle-Vererbung oder sowas.

01:16:15.050 --> 01:16:16.410
Ja, das passiert halt, genau,

01:16:16.490 --> 01:16:18.130
wenn man irgendwas falsch macht, dann passieren

01:16:18.130 --> 01:16:20.190
unerwartete Dinge, die man auch nicht so,

01:16:20.270 --> 01:16:21.830
die nicht so offensichtlich sind und

01:16:21.830 --> 01:16:24.190
ja, und es kann auch sehr schnell

01:16:24.190 --> 01:16:25.230
sehr hässlich werden, also

01:16:25.230 --> 01:16:28.330
es gibt wenig Fälle, wo das eine super

01:16:28.330 --> 01:16:30.150
sinnvolle Geschichte ist, das ist immer so, es ist halt so ein bisschen

01:16:30.150 --> 01:16:32.190
auch wieder wie bei den Dekoratoren, auch wenn man

01:16:32.190 --> 01:16:34.070
das am Anfang mal verstanden hat, wie das

01:16:34.070 --> 01:16:36.170
funktioniert, also ich meine, auch wenn man das mit der Vererbung

01:16:36.170 --> 01:16:37.610
verstanden hat, wie das funktioniert,

01:16:38.450 --> 01:16:40.110
dann ist das, dann fühlt sich das so toll an,

01:16:40.150 --> 01:16:42.050
dass man da ganz viele Dekoratoren machen will,

01:16:42.130 --> 01:16:44.030
ganz viele Vererbungen und am besten das

01:16:44.030 --> 01:16:46.150
Ganze irgendwie in verschachtelte List Comprehensions

01:16:46.150 --> 01:16:48.050
zackt oder so. Und mit Abzug Meta-Klassen

01:16:48.050 --> 01:16:49.710
bitte? Ja, Meta-Klassen, oh ja.

01:16:51.970 --> 01:16:53.910
Aber, ich weiß nicht,

01:16:54.130 --> 01:16:55.870
vielleicht keine gute Idee. Also jedenfalls nicht am Anfang.

01:16:56.310 --> 01:16:57.730
Also, wenn man

01:16:57.730 --> 01:17:00.010
dann irgendwann genau weiß, welches Problem man lösen

01:17:00.010 --> 01:17:01.870
möchte und man möchte halt ein Framework bauen,

01:17:02.110 --> 01:17:03.730
das halt, wo man dann, also nehmen wir

01:17:03.730 --> 01:17:06.010
sowas wie General REST Framework, finde ich das relativ gelungen.

01:17:06.990 --> 01:17:07.390
Da

01:17:07.390 --> 01:17:09.510
kann man oft viel Funktionalität

01:17:09.510 --> 01:17:11.850
abbilden, dadurch, dass man jetzt sozusagen von

01:17:11.850 --> 01:17:13.770
irgendeinem Viewset

01:17:13.770 --> 01:17:15.770
oder so erbt und dann überschreibt man noch

01:17:15.770 --> 01:17:17.830
zwei, drei Methoden, passt ein bisschen was an und dann macht das

01:17:17.830 --> 01:17:19.790
ganz viel. Sehr schön, aber

01:17:19.790 --> 01:17:21.690
dafür muss man sehr, sehr genau verstanden haben, welches

01:17:21.690 --> 01:17:22.850
Problem man hat und

01:17:22.850 --> 01:17:25.650
wenn man so anfängt,

01:17:25.790 --> 01:17:27.710
dann üblicherweise landet man

01:17:27.710 --> 01:17:29.770
relativ schnell

01:17:29.770 --> 01:17:30.970
in einem ziemlich üblen Zustand.

01:17:31.330 --> 01:17:32.370
Teufelsküche in der Schlangengrube.

01:17:34.630 --> 01:17:35.690
Man kann das ja immer noch machen

01:17:35.690 --> 01:17:37.610
am Schluss, wenn man dann irgendwie wirklich verstanden hat, was man tut

01:17:37.610 --> 01:17:39.390
und so, dann kann man ja immer noch dann irgendwie

01:17:39.390 --> 01:17:41.290
Klassengereiche hinbauen und so, aber am Anfang

01:17:41.290 --> 01:17:43.630
lieber nicht. Ich glaube, das ist jetzt der richtige Ort

01:17:43.630 --> 01:17:45.470
für die nächste Frage, die wäre, was ist ein

01:17:45.470 --> 01:17:46.050
Monkey-Patch.

01:17:47.930 --> 01:17:49.590
Ja, das ist, da das

01:17:49.590 --> 01:17:51.710
alles Objekte sind in Python, kann man

01:17:51.710 --> 01:17:52.790
die natürlich, und die alle

01:17:52.790 --> 01:17:55.770
dynamisch änderbar sind,

01:17:55.930 --> 01:17:57.550
kann man ja auch sozusagen einfach

01:17:57.550 --> 01:17:58.130
die Methode

01:17:58.130 --> 01:18:01.610
eines Objektes einfach, man kann ja sagen,

01:18:01.670 --> 01:18:02.350
zum Beispiel, wenn ich ja

01:18:02.350 --> 01:18:05.610
nicht nur Attribute setze, sondern ich kann auch die Methode einfach

01:18:05.610 --> 01:18:07.530
überschreiben. Ich könnte zum Beispiel sagen, wenn ich meinen

01:18:07.530 --> 01:18:09.290
Barbaren habe, von dem wir eben geredet haben,

01:18:09.450 --> 01:18:11.570
und er hat ein Attribut, das heißt Attacke,

01:18:11.570 --> 01:18:12.710
und da ist immer irgendwas drauf,

01:18:13.510 --> 01:18:15.430
dann kann ich einfach die überschreiben. Dann macht er bei der Attacke

01:18:15.430 --> 01:18:17.190
irgendwas anderes, zum Beispiel heilte ich oder so. Genau, genau.

01:18:17.390 --> 01:18:18.370
Und ich könnte einfach sagen,

01:18:19.290 --> 01:18:19.430
ja,

01:18:20.630 --> 01:18:23.410
barbar.attack gleich lambda x

01:18:23.410 --> 01:18:25.710
y z, was auch immer da übergeben wird.

01:18:25.930 --> 01:18:26.970
Das wäre zum Beispiel wahrscheinlich

01:18:26.970 --> 01:18:28.950
die Möglichkeit, wie man

01:18:28.950 --> 01:18:31.390
Vererbung bei Klassen richtig macht,

01:18:31.470 --> 01:18:33.030
indem man die Basisklasse hat, die wäre jetzt

01:18:33.030 --> 01:18:35.710
wahrscheinlich in so einem Rollenspiel

01:18:35.710 --> 01:18:36.870
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.290
weiß ich nicht, Rassen, zum Beispiel

01:18:41.290 --> 01:18:42.810
Echse oder Mensch oder sowas.

01:18:43.170 --> 01:18:45.150
naja, nee, ich bin 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.170
und dann kann man zum Beispiel Attacke

01:18:51.170 --> 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.510
ja, es ist...

01:19:18.510 --> 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.230
falsch.

01:19:39.310 --> 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 das halt auch immer so

01:19:42.810 --> 01:19:45.150
Programmierlehrbüchern oder so oft so

01:19:45.150 --> 01:19:46.670
oder schlimm ist es,

01:19:47.250 --> 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.670 --> 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-Zeit 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 hinauszuzö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 Weltformel die alles löst.

01:20:39.170 --> 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.610 --> 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.750 --> 01:21:08.970
Ganz normale Positionsargumente sind halt sozusagen das Übliche irgendwie.

01:21:08.970 --> 01:21:15.630
Die haben halt eine feste Stelle und werden dadurch dann identifiziert, dass sie halt an der ersten, zweiten, dritten Stelle oder so stehen.

01:21:16.610 --> 01:21:25.530
Und dann gibt es halt noch Keyword-Argumente, wo man dann explizit dazu sagt, welches Argument man denn jetzt gemeint hat.

01:21:26.290 --> 01:21:34.750
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.

01:21:34.750 --> 01:21:55.930
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, man kann die aber auch insgesamt übergeben.

01:21:55.930 --> 01:21:57.950
mit Stähnchen dann bei Argumenten oder mit

01:21:57.950 --> 01:21:59.910
Stähnchen, Stähnchen bei Keyword-Argumenten. Also wenn man

01:21:59.910 --> 01:22:01.910
die Liste hat in der Hand, wenn man

01:22:01.910 --> 01:22:04.130
eine Liste hat oder Tupel, dann kann man einfach einen Stern

01:22:04.130 --> 01:22:05.970
davor schreiben und dann

01:22:05.970 --> 01:22:07.790
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.610
Als Impact dann als Argument. Genau.

01:22:13.790 --> 01:22:14.490
Man sagt dann irgendwie

01:22:14.490 --> 01:22:18.150
Funktion, Klammer auf, Stern

01:22:18.150 --> 01:22:19.550
und dann eben

01:22:19.550 --> 01:22:21.950
Args, Argumente oder

01:22:21.950 --> 01:22:24.050
wie auch immer das die Items, die Struktur

01:22:24.050 --> 01:22:25.390
heißt, die man jetzt gerade in der Hand hat,

01:22:25.750 --> 01:22:28.150
Klammer zu und dann kann man in der Funktionsdefinition

01:22:28.150 --> 01:22:29.150
drinstehen haben, so was,

01:22:29.670 --> 01:22:32.010
Def-Funktion, Klammer auf, A, B,

01:22:32.170 --> 01:22:33.130
C und

01:22:33.130 --> 01:22:35.890
muss dann natürlich alles irgendwie stimmen von der Anzahl

01:22:35.890 --> 01:22:38.010
und so, aber das passiert dann automatisch.

01:22:38.030 --> 01:22:39.790
Ich finde das bei Keyword-Argumenten relativ nützlich, weil

01:22:39.790 --> 01:22:41.790
da kann man alle viele Sachen, die man irgendwie zugewiesen hat,

01:22:42.210 --> 01:22:43.670
irgendwie in eine Liste packen

01:22:43.670 --> 01:22:45.670
und dann kann man die einfach alles mit

01:22:45.670 --> 01:22:47.430
Sternchen übergeben und hat dann seine Keywords.

01:22:48.050 --> 01:22:49.390
Genau, das eben

01:22:49.390 --> 01:22:52.110
bei normalen Positionsargumenten ist es halt

01:22:52.110 --> 01:22:53.630
entweder man übergibt sie

01:22:53.630 --> 01:22:55.370
Perposition oder Stern

01:22:55.370 --> 01:22:58.210
kann auch eben in der Funktionsdefinition

01:22:58.210 --> 01:23:00.110
sagen, das können jetzt hier beliebig viele sein,

01:23:00.170 --> 01:23:02.130
dann schreibt man halt nicht a, b, c rein, sondern

01:23:02.130 --> 01:23:03.550
Stern, args,

01:23:04.430 --> 01:23:05.690
Komma, und dann da

01:23:05.690 --> 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.470 --> 01:23:15.470
Das geht in Python auch,

01:23:16.330 --> 01:23:17.430
ist da aber ein Spezialfall.

01:23:18.770 --> 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
Sternstern. Und damit lassen sich

01:23:25.650 --> 01:23:26.470
halt sehr, sehr leicht

01:23:26.470 --> 01:23:28.670
zum Beispiel Dicts in

01:23:28.670 --> 01:23:31.790
Keyword-Argumente verwandeln und Keyword-Argumente

01:23:31.790 --> 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 erspart.

01:23:41.210 --> 01:23:41.610
Cool.

01:23:42.410 --> 01:23:43.510
Jetzt haben wir noch zwei Sachen, die noch

01:23:43.510 --> 01:23:45.470
ein bisschen in diese Funktion reingehen. Wir haben ja

01:23:45.470 --> 01:23:46.810
Funktionen, jetzt jede Menge so Sachen.

01:23:47.670 --> 01:23:49.410
Was ist dann Lambda-Funktion? Was macht die denn dann?

01:23:50.310 --> 01:23:51.690
Haben wir, glaube ich, auch schon einmal kurz besprochen.

01:23:52.410 --> 01:23:53.710
Ist eigentlich nichts Besonderes.

01:23:53.810 --> 01:23:55.890
Es ist eine Funktion

01:23:55.890 --> 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.190 --> 01:24:00.790
ich meine ja auch

01:24:00.790 --> 01:24:03.630
ein bisschen JavaScript und das ist da so

01:24:03.630 --> 01:24:05.590
schon ein Stückchen eleganter vielleicht.

01:24:06.830 --> 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.590
oder anonyme Funktionen über

01:24:11.590 --> 01:24:12.510
mehrere Zeilen oder sowas.

01:24:13.310 --> 01:24:14.730
Sondern da gibt es halt Lambda.

01:24:17.390 --> 01:24:18.370
Warum muss das überhaupt sein?

01:24:18.470 --> 01:24:19.210
Wofür braucht man sowas?

01:24:19.710 --> 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.390 --> 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.890
jetzt irgendwie, wenn man

01:24:35.890 --> 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:50.930
super langsam sind in Python.

01:24:51.230 --> 01:25:13.490
Und was jetzt nicht heißen soll, Vorschleifen sind halt schon gut, aber wenn man jetzt über ein Array mit ein paar Millionen Einträgen iteriert, dann will man das vielleicht nicht als Vorschleife hinschreiben, sondern was man dann hinschreibt, ist halt irgendwas DataFrame.apply und dann übergibt man eine Funktion, die dann halt das macht, was man jetzt eigentlich im Body einer Vorschleife gerne gemacht hätte, aber die man ja nicht hinschreiben kann.

01:25:14.190 --> 01:25:15.750
Diese Funktion hat aber sonst keinen

01:25:15.750 --> 01:25:17.770
Zweck. Die ist nicht, an anderer Stelle

01:25:17.770 --> 01:25:19.670
braucht man die nicht, weil eigentlich, was man hätte hinschreiben

01:25:19.670 --> 01:25:21.450
wollen, wäre eine Vorschleife gewesen und dann

01:25:21.450 --> 01:25:23.730
das, was man mit dieser Vorschleife macht, halt machen.

01:25:24.410 --> 01:25:25.430
Aber das geht halt nicht.

01:25:25.590 --> 01:25:26.010
Daher

01:25:26.010 --> 01:25:29.650
braucht man halt jetzt diese temporäre

01:25:29.650 --> 01:25:31.590
Funktion, der man jetzt auch gar keinen, gar nicht unbedingt

01:25:31.590 --> 01:25:33.810
Namen 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.430 --> 01:25:41.790
Lambda

01:25:41.790 --> 01:25:43.890
gibt halt sozusagen,

01:25:44.110 --> 01:25:45.850
also Lambda x Doppelpunkt

01:25:45.850 --> 01:25:47.350
x

01:25:47.350 --> 01:25:49.670
zum Quadrat oder sowas,

01:25:50.430 --> 01:25:52.050
würde halt ein Argument

01:25:52.050 --> 01:25:53.870
nehmen und dieses Argument mit sich

01:25:53.870 --> 01:25:55.310
selbst multiplizieren und dann wieder zurückgeben.

01:25:56.050 --> 01:25:57.770
Nur dass man halt das Return

01:25:57.770 --> 01:25:59.690
weglassen muss, also

01:25:59.690 --> 01:26:01.330
Return kann man nicht hinschreiben in der Lambda,

01:26:01.890 --> 01:26:03.870
sondern es ist halt das, was

01:26:03.870 --> 01:26:05.610
halt man, das Letzte, was irgendwie

01:26:05.610 --> 01:26:07.470
Es ist implizit, nicht explizit.

01:26:07.930 --> 01:26:09.530
Implizit wird das halt einfach zurückgegeben.

01:26:10.490 --> 01:26:11.510
Und ja,

01:26:11.730 --> 01:26:13.910
auch die Argumentübergabe

01:26:13.910 --> 01:26:15.870
ist ein bisschen anders. Es ist halt nicht irgendwie Klammer

01:26:15.870 --> 01:26:17.830
auf und dann irgendwas, sondern es ist halt einfach

01:26:17.830 --> 01:26:19.650
Leerzeichen und dann Liste der

01:26:19.650 --> 01:26:21.310
Argumente, Doppelpunkt

01:26:21.310 --> 01:26:23.310
und das wird halt implizit

01:26:23.310 --> 01:26:25.610
passiert. Und es kann alles nur in einer Zeile stehen.

01:26:25.730 --> 01:26:26.130
Es darf nicht

01:26:26.130 --> 01:26:28.450
mehrere Zeilen.

01:26:28.450 --> 01:26:30.390
Es ist aber so ein bisschen hässlich.

01:26:31.090 --> 01:26:32.410
Auf der anderen Seite ist es so, wenn das

01:26:32.410 --> 01:26:34.110
komplizierter wird, man muss das ja nicht so machen.

01:26:34.210 --> 01:26:36.350
Man kann auch tatsächlich eine Funktion hinschreiben, die man

01:26:36.350 --> 01:26:37.870
einfach irgendwie nennt.

01:26:39.230 --> 01:26:40.270
Kann man ja auch sagen, irgendwie

01:26:40.270 --> 01:26:42.270
rechne mir irgendwie das

01:26:42.270 --> 01:26:44.190
Quadrat aus oder so Funktion

01:26:44.190 --> 01:26:46.150
und dann schreibt man halt in diese Funktion,

01:26:46.150 --> 01:26:47.950
da kann man ja auch mehrere Zeilen schreiben, die schreibt man dann da rein

01:26:47.950 --> 01:26:49.470
und dann übergibt man das Ding halt.

01:26:49.950 --> 01:26:50.450
Der Lambda-Funktion.

01:26:51.630 --> 01:26:54.210
Nicht der Lambda, sondern übergibt das statt der Lambda-Funktion,

01:26:54.310 --> 01:26:55.190
weil es ist genau das Gleiche.

01:26:56.090 --> 01:26:57.950
Das, was man zurückbekommt von diesem Lambda, ist auch nichts.

01:26:57.950 --> 01:26:59.530
Das heißt, Lambda braucht man eigentlich überhaupt nicht.

01:27:00.150 --> 01:27:01.330
Nee, man braucht es nicht.

01:27:01.690 --> 01:27:03.810
Es ist halt manchmal auch nett,

01:27:03.990 --> 01:27:05.910
das so hinschreiben zu können, aber wirklich brauchen

01:27:05.910 --> 01:27:06.390
tut man es nicht.

01:27:07.650 --> 01:27:09.950
Spart ein bisschen Schreibarbeit für zum Beispiel so einfache Operationen

01:27:09.950 --> 01:27:11.710
wie einfach Quadrat zu geben, dann kann man einfach das Lambda

01:27:11.710 --> 01:27:13.590
in die Zeile schreiben, wenn man es nicht wieder sonst braucht.

01:27:14.050 --> 01:27:15.590
Genau, weil du hast halt, wenn du

01:27:15.590 --> 01:27:17.370
Funktionen hinschreibst in Python, immer

01:27:17.370 --> 01:27:19.310
einen gewissen Zeilen-Overhead, weil

01:27:19.310 --> 01:27:21.570
naja, da die

01:27:21.570 --> 01:27:23.790
Umbrüche syntaktisch

01:27:23.790 --> 01:27:25.770
relevant sind und die Eindrückung, ist es halt

01:27:25.770 --> 01:27:27.350
so, dass du da auf jeden Fall immer mehrere,

01:27:27.510 --> 01:27:29.490
mindestens mal zwei Zeilen für hinschreiben musst.

01:27:30.770 --> 01:27:31.830
Ja, und mit Lambda kannst

01:27:31.830 --> 01:27:33.550
du es auch in einer Zeile hinschreiben. Und wenn das wirklich

01:27:33.550 --> 01:27:35.530
eine ganz simple Geschichte ist, dann willst du

01:27:35.530 --> 01:27:37.570
vielleicht nicht deswegen eine Funktion definieren,

01:27:37.710 --> 01:27:39.570
sondern, ja, aber

01:27:39.570 --> 01:27:41.450
letztlich kann man dafür auch ganz normale

01:27:41.450 --> 01:27:42.350
Funktionen verwenden

01:27:42.350 --> 01:27:45.670
und was ja an Python auch geht, was auch schön ist,

01:27:45.750 --> 01:27:47.590
du kannst halt innerhalb von Funktionen

01:27:47.590 --> 01:27:49.530
auch wieder Funktionen definieren. Also du musst ja

01:27:49.530 --> 01:27:51.530
nicht die Funktionen dann außerhalb der Funktionen, das heißt, du kannst

01:27:51.530 --> 01:27:53.570
die Funktionen auch direkt da an die Stelle schreiben, wo

01:27:53.570 --> 01:27:55.570
du sie verwenden willst. Wann macht man das

01:27:55.570 --> 01:27:57.470
denn alle, dass man so schachtelte Funktionen macht?

01:27:57.730 --> 01:27:59.450
Ja, eben. Zum Beispiel, wenn du halt eine Funktion

01:27:59.450 --> 01:28:01.430
sonst nirgendwo verwenden möchtest und

01:28:01.430 --> 01:28:03.010
möchtest halt, aber du brauchst eine Funktion.

01:28:04.210 --> 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.570
wo du eine Funktion zurückgibst, die

01:28:09.570 --> 01:28:11.150
halt 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.170
dieser Funktion liegen.

01:28:16.610 --> 01:28:17.050
Also wenn du,

01:28:18.790 --> 01:28:19.790
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:39.930
irgendwas initialisiert wird. Also genau, das

01:28:39.930 --> 01:29:08.930
Zum Beispiel können wir mal nehmen, sagen wir mal, def, zähle ab, Klammer auf, x, Klammer zu, Doppelpunkt, counter gleich x und dann def inner, Klammer auf, y, Klammer zu, Doppelpunkt und dann return.

01:29:09.930 --> 01:29:11.010
Range

01:29:11.010 --> 01:29:12.510
Counter,

01:29:12.890 --> 01:29:15.670
Counter,

01:29:16.210 --> 01:29:16.850
Y oder so.

01:29:17.150 --> 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.590
diesen State wieder halten irgendwo

01:29:25.590 --> 01:29:27.390
und du möchtest ihn irgendwo halten, wo jetzt

01:29:27.390 --> 01:29:29.390
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.110 --> 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.450
Und

01:29:49.450 --> 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.550 --> 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:26.970
um sozusagen, gib mir einen Counter, der ab 5 zählt immer.

01:30:27.350 --> 01:30:28.990
Oder gib mir einen Counter, der ab 10 zählt immer.

01:30:29.390 --> 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.870
aber das ist halt auch die Art, wie dann irgendwie Dekoratoren

01:30:37.870 --> 01:30:39.150
und

01:30:39.150 --> 01:30:42.590
Context-Manager

01:30:42.590 --> 01:30:44.490
und so funktionieren, die machen da

01:30:44.490 --> 01:30:46.530
Dinge in der Richtung.

01:30:47.770 --> 01:30:47.850
Ja.

01:30:49.550 --> 01:30:50.370
Genau. Aber

01:30:50.370 --> 01:30:51.930
das finde ich auch

01:30:51.930 --> 01:30:54.350
sehr schön, dass man halt in Funktionen auch locker

01:30:54.350 --> 01:30:56.450
irgendwie Funktionen definieren kann und man kann auch

01:30:56.450 --> 01:30:57.990
Klassen innerhalb von Klassen definieren und so.

01:30:58.770 --> 01:30:59.990
Also das geht einfach problemlos.

01:31:01.990 --> 01:31:02.570
Klingt nach

01:31:02.570 --> 01:31:04.330
viel Konfusion für die Anfänger,

01:31:04.450 --> 01:31:05.230
die jetzt gerade da sind.

01:31:05.490 --> 01:31:08.130
Vielleicht sollte man das mal

01:31:08.130 --> 01:31:08.710
doch nicht machen.

01:31:11.090 --> 01:31:11.810
Ich habe jetzt noch

01:31:11.810 --> 01:31:13.990
eine Basisfrage. Was ist der Unterschied von einer

01:31:13.990 --> 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.470
ein gleich gleich oder ein ist? Also

01:31:21.470 --> 01:31:23.110
A gleich gleich B, A ist B.

01:31:23.690 --> 01:31:25.930
Etwas ist gleich gleich none, ist none.

01:31:27.070 --> 01:31:27.250
Ja.

01:31:28.430 --> 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.730 --> 01:31:35.710
also gleich ist natürlich irgendwie Zuweisung,

01:31:35.890 --> 01:31:37.610
aber gleich gleich, da wird halt

01:31:37.610 --> 01:31:39.090
der Wert verglichen.

01:31:43.210 --> 01:31:45.970
Und bei is wird verglichen,

01:31:46.430 --> 01:31:47.450
ob es das gleiche Objekt ist.

01:31:48.470 --> 01:31:49.490
Und deswegen sagt man zum Beispiel bei

01:31:49.490 --> 01:31:51.470
none, sagt man immer is none, weil es nur

01:31:51.470 --> 01:31:53.390
ein none-Objekt gibt. Genau, none ist ein

01:31:53.390 --> 01:31:53.670
Singleton.

01:31:55.290 --> 01:31:57.090
Und deswegen kann ich halt so testen,

01:31:57.290 --> 01:31:58.910
ob es wirklich none ist.

01:31:59.630 --> 01:32:00.730
True und false sind auch Singleton.

01:32:03.730 --> 01:32:11.910
Ja, bin ich mir jetzt nicht so

01:32:11.910 --> 01:32:13.310
ganz sicher, aber ich glaube schon.

01:32:14.910 --> 01:32:15.890
Ich weiß aber

01:32:15.890 --> 01:32:17.990
nicht genau. Ja, so müsste wahrscheinlich so sein.

01:32:18.150 --> 01:32:19.110
Das könnte eigentlich gar nicht anders.

01:32:20.630 --> 01:32:21.790
Okay, das heißt, ihr müsst halt tatsächlich,

01:32:21.890 --> 01:32:23.310
wenn es ist, immer genau das Objekt.

01:32:23.590 --> 01:32:25.630
Ich weiß nicht, man kann das

01:32:25.630 --> 01:32:27.910
auch zuweisen. Also es ist auch

01:32:27.910 --> 01:32:30.110
ganz böse. Man kann True und False

01:32:30.110 --> 01:32:31.270
auch noch anders belegen. Also

01:32:31.270 --> 01:32:33.070
müsste man mal nachgucken.

01:32:33.730 --> 01:33:00.450
Ja, das, was irgendwie spannend ist, weil jetzt, wir haben ja so ein paar Mal über so Sachen geredet, was jetzt irgendwie Klassen sind und Objekte und Typen, dass alle Sachen in Python irgendwelche Objekte sind, irgendwelche Typen sind und dann habe ich mich irgendwie gefragt, ob jetzt nicht die ganzen Zuweisungen, also man kann jetzt irgendwie Typen umwandeln, ja, also von Integer auf String oder sowas, ob das nicht halt auch eine Klasse dann eigentlich ist, die man dann halt nimmt, weil das halt ein Typ ist, ein Objekt ist und deswegen müsste das eigentlich groß geschrieben werden, weil man halt eine Instanz eines Objektes ändert und eine Instanz eines Objektes erzeugt.

01:33:00.450 --> 01:33:02.070
Zum Beispiel von einer Instanz eines Objektes

01:33:02.070 --> 01:33:04.030
String, eine Instanz eines Objektes Integer wechselt.

01:33:04.050 --> 01:33:05.950
Wenn man ein Int vorstellt, es muss ein bisschen großes Int sein,

01:33:06.570 --> 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.870 --> 01:33:14.150
woher das kommt. Ich weiß es ehrlich gesagt auch nicht so genau.

01:33:15.970 --> 01:33:18.090
Vielleicht weiß das jemand besser und kann mich da korrigieren.

01:33:18.190 --> 01:33:19.850
Aber ich denke mal, es liegt daran,

01:33:19.850 --> 01:33:21.450
dass das Build-Ins sind.

01:33:22.550 --> 01:33:23.850
Also ja, eigentlich die Konvention

01:33:23.850 --> 01:33:25.810
in Python ist so, wenn es eine Klasse ist, dann schreibt man

01:33:25.810 --> 01:33:26.350
das halt groß.

01:33:27.790 --> 01:33:28.190
Aber

01:33:28.190 --> 01:33:31.330
ich glaube, alle Build-Ins sind klein.

01:33:32.570 --> 01:33:33.430
Und da das Build-Ins

01:33:33.430 --> 01:33:33.910
sind,

01:33:35.790 --> 01:33:36.850
sagt man eher,

01:33:37.190 --> 01:33:39.190
das ist wichtiger, weil es gibt nicht so viele Build-Ins.

01:33:39.210 --> 01:33:40.590
Aber richtig wäre es tatsächlich, dass man,

01:33:41.090 --> 01:33:42.730
zum Verständnis vielleicht, dass man irgendwie,

01:33:43.090 --> 01:33:44.490
wenn man einen Typ ändert,

01:33:44.830 --> 01:33:46.830
einer Variable beispielsweise, dass man einen neuen

01:33:46.830 --> 01:33:48.990
Instanz, eine neue oder eine andere Klasse erzeugt.

01:33:49.450 --> 01:33:51.110
Ja, ja, das ist so. Aber das passiert

01:33:51.110 --> 01:33:52.690
auch tatsächlich. Also wenn ich sage int

01:33:52.690 --> 01:33:54.410
Klammer auf 5, Klammer zu,

01:33:55.170 --> 01:33:57.350
dann wird ein neues Integer-Objekt

01:33:57.350 --> 01:33:59.230
erzeugt. Genau, mit dem Word 5.

01:34:00.650 --> 01:34:01.350
Also es ist tatsächlich

01:34:01.350 --> 01:34:02.130
ja,

01:34:03.470 --> 01:34:04.470
auch Dict ist ja

01:34:04.470 --> 01:34:06.730
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.490 --> 01:34:11.570
aber ich

01:34:11.570 --> 01:34:13.430
kann davon erben und das funktioniert auch.

01:34:15.310 --> 01:34:15.710
Aber

01:34:15.710 --> 01:34:17.450
ja, ich denke, das hängt damit

01:34:17.450 --> 01:34:19.370
zusammen, dass die Build Insights so Spezialfälle

01:34:19.370 --> 01:34:21.250
sind. Wenn ich die Klassen verwenden möchte,

01:34:21.290 --> 01:34:23.090
für die ganzen Dinger gibt es auch noch richtige Klassen.

01:34:24.550 --> 01:34:25.210
Zum Beispiel

01:34:25.210 --> 01:34:25.790
für

01:34:25.790 --> 01:34:29.070
Dict und List und so gibt es

01:34:29.070 --> 01:34:30.250
UserDict und UserList.

01:34:31.410 --> 01:34:33.090
Und auch wenn ich jetzt irgendwie

01:34:33.090 --> 01:34:35.290
selber ein eigenes Dict, das Dinge

01:34:35.290 --> 01:34:36.710
ein bisschen anders macht als ein normales Dict

01:34:36.710 --> 01:34:38.530
verwenden möchte, dann

01:34:38.530 --> 01:34:41.190
sollte ich halt irgendwie von UserDict

01:34:41.190 --> 01:34:42.890
erben und nicht von einfach nur

01:34:42.890 --> 01:34:43.570
kleingeschriebenem Dict.

01:34:45.570 --> 01:34:47.170
Das ist wieder wie du das nie, weil sich

01:34:47.170 --> 01:34:49.130
schon Leute rumgekümmert haben, bestimmte Probleme zu umgehen,

01:34:49.190 --> 01:34:50.370
auf die man dann stößt, wenn man das nicht macht.

01:34:50.370 --> 01:34:51.190
Ja, genau, genau.

01:34:53.310 --> 01:34:53.670
Ja.

01:34:54.750 --> 01:34:56.270
Ja, jetzt haben wir, wir haben noch jede Menge,

01:34:56.470 --> 01:34:58.650
ich weiß gar nicht, ob wir das heute in der Folge alles irgendwie unterkriegen,

01:34:59.270 --> 01:35:00.730
noch einer hat gefragt, was denn eine

01:35:00.730 --> 01:35:01.530
Shallow-Copy ist.

01:35:02.550 --> 01:35:04.730
Wie arbeitet man richtig mit Listen

01:35:04.730 --> 01:35:06.710
im Zusammenhang mit Funktionen, oder gibt man eine Kopie

01:35:06.710 --> 01:35:08.710
und retournt eine neue Liste, oder gibt man eine

01:35:08.710 --> 01:35:10.650
Liste und ändert die quasi in Plays?

01:35:11.510 --> 01:35:12.250
Was hat das damit zu tun?

01:35:12.490 --> 01:35:12.770
Also irgendwie.

01:35:16.150 --> 01:35:16.470
Ja,

01:35:16.590 --> 01:35:18.630
das ist auch eine unter Umständen

01:35:18.630 --> 01:35:20.090
Stilfrage, was man da machen

01:35:20.090 --> 01:35:21.610
möchte.

01:35:23.870 --> 01:35:24.570
Also einmal

01:35:24.570 --> 01:35:26.330
vielleicht zuerst das mit der

01:35:26.330 --> 01:35:28.370
Shallow-Kopie, also

01:35:28.370 --> 01:35:30.290
die Frage ist, was passiert eigentlich,

01:35:30.410 --> 01:35:32.250
wenn ich jetzt sozusagen

01:35:32.250 --> 01:35:34.330
eine Kopie von irgendwas machen möchte und

01:35:34.330 --> 01:35:38.950
weil ich

01:35:38.950 --> 01:35:42.290
warum auch immer irgendwie eine zweite

01:35:42.290 --> 01:35:44.050
Version von irgendeiner Datenstruktur brauche oder so,

01:35:45.070 --> 01:35:45.950
da ist es, wenn ich jetzt

01:35:45.950 --> 01:35:48.230
die einfach nur kopiere, also

01:35:48.230 --> 01:35:48.990
wenn ich jetzt, also

01:35:48.990 --> 01:35:52.270
in Python habe ich eigentlich meine Referenzen auf solche

01:35:52.270 --> 01:35:54.290
Datenstrukturen in der Hand, also

01:35:54.290 --> 01:35:56.290
auch die Übergabe von Sachen

01:35:56.290 --> 01:35:58.030
ist immer bei Referenz, also es gibt ja

01:35:58.030 --> 01:35:59.810
ein C, es ist unter Umständen anders, da gibt es halt

01:35:59.810 --> 01:36:01.950
kann ich Argumente übergeben

01:36:01.950 --> 01:36:04.090
als Referenz oder

01:36:04.090 --> 01:36:04.810
halt als

01:36:04.810 --> 01:36:07.510
Wert, also

01:36:07.510 --> 01:36:09.810
direkt den Wert einfach so

01:36:09.810 --> 01:36:11.930
und in Python ist es immer

01:36:11.930 --> 01:36:13.750
per Referenz, also

01:36:13.750 --> 01:36:16.270
in der Variable, die ich übergebe

01:36:16.270 --> 01:36:18.010
steht immer sozusagen einfach eine Speicheradresse

01:36:18.010 --> 01:36:20.090
drin, die halt auf das Objekt zeigt, das ich übergebe

01:36:20.090 --> 01:36:22.050
und ich übergebe immer nur die Adresse, ich

01:36:22.050 --> 01:36:23.990
übergebe nicht der Funktion, das

01:36:23.990 --> 01:36:24.830
Objekt selbst

01:36:24.830 --> 01:36:28.030
und jetzt ist es halt so, wenn ich

01:36:28.030 --> 01:36:28.930
einfach nur

01:36:28.930 --> 01:36:31.830
bestimmte Operationen duplizieren mir halt

01:36:31.830 --> 01:36:33.770
jetzt diese Adresse, aber nicht den Inhalt

01:36:33.770 --> 01:36:35.850
dahinter. Das heißt, wenn ich jetzt

01:36:35.850 --> 01:36:37.750
ich mache eine Kopie davon, ich muss

01:36:37.750 --> 01:36:39.550
mal überlegen, in welchen Umständen ich das hinkriege.

01:36:42.410 --> 01:36:43.150
Wenn ich jetzt

01:36:43.150 --> 01:36:45.810
wenn ich jetzt einfach

01:36:45.810 --> 01:36:46.630
nur copy

01:36:46.630 --> 01:36:50.410
ich weiß nicht, ob

01:36:50.410 --> 01:36:51.810
copy in built-in ist, aber wenn ich

01:36:51.810 --> 01:36:53.670
einfach nur sage, kopier mir das mal,

01:36:53.730 --> 01:36:55.230
dann kann es sein, dass mir nur die Referenz kopiert wird.

01:36:55.310 --> 01:36:57.370
Das heißt, mir wird halt die Speicheradresse

01:36:57.370 --> 01:36:59.330
in eine andere Variable kopiert, aber wenn ich jetzt

01:36:59.330 --> 01:37:01.030
irgendwas am Inhalt einer Liste oder so ändere,

01:37:01.530 --> 01:37:02.910
dann ist das in beiden Listen geändert.

01:37:03.270 --> 01:37:05.150
Und das ist unter Umständen nicht so intuitiv.

01:37:05.630 --> 01:37:07.290
Vielleicht hätte man jetzt nicht

01:37:07.290 --> 01:37:08.050
so mit gerechnet, sondern

01:37:08.050 --> 01:37:11.350
man hätte damit gerechnet, dass ich jetzt zwei Listen habe,

01:37:11.470 --> 01:37:13.310
die im Hauptspeicher an zwei unterschiedlichen

01:37:13.310 --> 01:37:14.130
Stellen liegen.

01:37:15.490 --> 01:37:17.210
Und eine Shallow-Copy ist halt eine,

01:37:17.210 --> 01:37:19.250
die nur sozusagen

01:37:19.250 --> 01:37:21.410
also bei einer Liste

01:37:21.410 --> 01:37:23.170
könnte ich mir jetzt sogar vorstellen, dass es oft,

01:37:23.270 --> 01:37:25.290
wenn ich jetzt nochmal Lists drumherum schreibe oder so,

01:37:25.330 --> 01:37:26.630
dass dann tatsächlich eine Kopie erzeugt wird.

01:37:27.290 --> 01:37:28.830
Also eine Nicht-Cello-Kopie, aber

01:37:28.830 --> 01:37:30.750
wenn ich jetzt eine komplizierte

01:37:30.750 --> 01:37:33.210
Datenstruktur habe in irgendeinem Dikt oder so,

01:37:33.450 --> 01:37:35.170
wo viele Sachen ineinander

01:37:35.170 --> 01:37:37.090
verschachtelt drin liegen, dann ist es so, wenn ich

01:37:37.090 --> 01:37:39.190
jetzt sage Dikt von dem Ding, dann ist

01:37:39.190 --> 01:37:40.930
es eine, oder wenn ich sage Kopie,

01:37:41.610 --> 01:37:42.770
dann ist das eine Cello-Kopie

01:37:42.770 --> 01:37:43.830
und

01:37:43.830 --> 01:37:47.210
sozusagen. Warum brauche ich dann überhaupt

01:37:47.210 --> 01:37:49.050
eine Cello-Kopie? Dann könnte ich auch einfach auf das normale Dikt zeigen,

01:37:49.050 --> 01:37:50.250
wenn es eh nur auf das gleiche Objekt zeigt.

01:37:50.570 --> 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:38:02.950
dann gibt es zum Beispiel eine Funktion aus dem Copy.

01:38:03.030 --> 01:38:04.430
Ich glaube, das ist Standardbibliothek.

01:38:04.850 --> 01:38:06.470
Dann sagt man immer Form Copy, Import Deep Copy.

01:38:06.950 --> 01:38:07.770
Und dann sagt man Deep Copy,

01:38:08.510 --> 01:38:11.190
irgendwie komplizierte, dick verschattelte Datenstruktur.

01:38:11.950 --> 01:38:13.410
Und die geht dann rekursiv da durch

01:38:13.410 --> 01:38:15.830
und kopiert den ganzen Kram da raus in eine andere Datenstruktur.

01:38:15.830 --> 01:38:18.230
Und dann habe ich das tatsächlich getrennt voneinander.

01:38:18.790 --> 01:38:20.670
Aber ansonsten ist das halt nicht so einfach.

01:38:20.890 --> 01:38:24.230
wenn ich da Dict drumherum mache,

01:38:24.350 --> 01:38:25.510
dann kann es zwar auch sein,

01:38:25.630 --> 01:38:27.390
dass es ein neues Dict ist an einer anderen Speicheradresse

01:38:27.390 --> 01:38:30.750
und dass ich die Keys und Values kopiert habe,

01:38:30.810 --> 01:38:32.790
aber die Values waren halt Referenzen auf irgendwas

01:38:32.790 --> 01:38:34.530
und die Objekte hinter diesen Referenzen

01:38:34.530 --> 01:38:35.410
haben sich halt nicht geändert.

01:38:35.670 --> 01:38:36.990
Und das kann halt sehr...

01:38:36.990 --> 01:38:38.190
Da kann man sich ein bisschen mit in den Fuß schießen,

01:38:38.270 --> 01:38:40.010
wenn man sowas übergibt wie leere Listen

01:38:40.010 --> 01:38:41.290
als Standardwert vom Keyword.

01:38:41.530 --> 01:38:43.890
Ja, da kann man sich böse in den Fuß schießen mit.

01:38:43.990 --> 01:38:46.590
Weil dann, also das ist, glaube ich, generell das Problem.

01:38:46.710 --> 01:38:48.570
Also bei so ein paar Sachen, die man als Keyword setzt,

01:38:48.670 --> 01:38:49.850
wenn man jetzt irgendwie eine Funktion hat,

01:38:49.850 --> 01:38:56.870
Da wird ein Keyword übergeben, das setzt man einem Default-Wert, indem es zum Beispiel eine leere Liste hat oder einen random initialisierten Wert oder sowas.

01:38:57.530 --> 01:39:02.950
Der wird halt beim ersten Mal dann initialisiert und dann steht dann halt aber in der Speicheradresse dieser Wert drin, der dann halt dem zugewiesen ist schon.

01:39:03.230 --> 01:39:06.710
Weil das halt dann nur darauf zeigt und halt nicht jedes Mal ein neues Objekt generiert.

01:39:06.790 --> 01:39:11.610
Und das heißt, man hat immer dieselbe leere Liste, die dann vielleicht nicht mehr leer ist, nachdem man die Funktion einmal aufgerufen hat.

01:39:11.770 --> 01:39:18.170
Und dann ist es immer die gleiche und dann funktioniert es sogar oft und dann irgendwann fällt es einem ganz furchtbar auf den Fuß und man weiß nicht genau.

01:39:18.170 --> 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.070 --> 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.650 --> 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.250
Klammer auf, Klammer zu oder so.

01:39:38.510 --> 01:39:40.970
Man sagt immer None und dann macht man eine Überprüfung,

01:39:41.050 --> 01:39:42.910
ob es None ist und dann setzt man die Liste

01:39:42.910 --> 01:39:44.710
neu. Das ist halt echt nur eine böse Fußengel.

01:39:45.070 --> 01:39:46.250
Also das kann

01:39:46.250 --> 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.070 --> 01:39:53.150
Also wenn ihr jetzt irgendwo so ein Zufallswert generieren lassen wollt,

01:39:53.250 --> 01:39:55.150
wie von Random-Rant 1 bis 10

01:39:55.150 --> 01:39:56.970
oder sowas, 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:40:00.890
einen default neuen Zufallswert zurück, sondern immer

01:40:00.890 --> 01:40:02.730
dasselbe. Also das ist an der Stelle

01:40:02.730 --> 01:40:04.910
nicht intuitiv. Also fand ich auch sehr

01:40:04.910 --> 01:40:07.050
komisch, dass er dann nicht einfach jedes Mal beim Aufrufen

01:40:07.050 --> 01:40:09.030
das neu initialisiert, sondern dass er halt dann die Objekte

01:40:09.030 --> 01:40:10.810
nimmt, die er einmal schon irgendwo liegen hat.

01:40:12.290 --> 01:40:12.650
Ja,

01:40:12.990 --> 01:40:14.970
also wie man, also eine

01:40:14.970 --> 01:40:16.930
Geschichte, wie man, also List Comprehension

01:40:16.930 --> 01:40:18.610
macht immer eine Kopie, wenn man zum Beispiel

01:40:18.610 --> 01:40:19.830
erzeugt immer eine neue Liste.

01:40:20.970 --> 01:40:23.110
Ansonsten, ja, die Kopie aus dem Kopiemodul,

01:40:23.210 --> 01:40:24.870
wenn es kompliziertere Datenstrukturen sind, dann muss man

01:40:24.870 --> 01:40:26.750
sich das nicht selber, also oft ist es ja, ich meine, es ist ja

01:40:26.750 --> 01:40:27.810
wirklich kompliziert, wenn man da halt

01:40:27.810 --> 01:40:30.930
was, ja, man muss halt

01:40:30.930 --> 01:40:32.830
rekursiv durchgehen und das will man ja vielleicht auch nicht selber

01:40:32.830 --> 01:40:34.250
schreiben und da gibt es halt schon ein Ding für,

01:40:34.750 --> 01:40:36.610
was man da benutzen kann. Dann

01:40:36.610 --> 01:40:38.750
ist es so, naja, was diese unterschiedlichen

01:40:38.750 --> 01:40:39.950
Stile angeht, also

01:40:39.950 --> 01:40:42.550
wenn man sich so ein bisschen

01:40:42.550 --> 01:40:44.310
anguckt, was in den, es gibt ja

01:40:44.310 --> 01:40:46.450
unterschiedliche Arten zu programmieren,

01:40:46.570 --> 01:40:48.390
ja, so imperativ. Ich würde auch Python

01:40:48.390 --> 01:40:50.490
eher, auch wenn man es auch mit Berechtigung

01:40:50.490 --> 01:40:52.110
sagen kann, es ist auch irgendwie eine funktionale

01:40:52.110 --> 01:40:53.410
Programmiersprache,

01:40:54.210 --> 01:40:56.370
ist es doch eher, die meisten Leute verwenden es halt

01:40:56.370 --> 01:40:57.110
irgendwie imperativ.

01:40:59.270 --> 01:40:59.630
Und

01:40:59.630 --> 01:41:02.530
in dem Lager sozusagen

01:41:02.530 --> 01:41:04.510
Paradigma der funktionalen Programmiersprachen

01:41:04.510 --> 01:41:06.590
ist es aber eher so, dass man halt da

01:41:06.590 --> 01:41:08.430
und nicht nur da, das setzt

01:41:08.430 --> 01:41:10.130
sich auch in anderen Bereichen durch. In JavaScript

01:41:10.130 --> 01:41:11.350
sehen wir das in letzter Zeit oft,

01:41:12.050 --> 01:41:14.510
auch wenn es um so State-Handling-Geschichten geht,

01:41:14.970 --> 01:41:17.650
da gibt es dann Redux und so,

01:41:19.690 --> 01:41:24.250
dass man, wenn man jetzt solche Sachen handelt,

01:41:25.110 --> 01:41:28.270
versucht immer nur mit Datenstrukturen zu arbeiten,

01:41:28.470 --> 01:41:31.130
die nicht veränderbar sind, also die mutable sind

01:41:31.130 --> 01:41:34.310
und immer nur Kopien erzeugt, wenn man irgendwas ändert.

01:41:34.510 --> 01:41:36.750
Also man ändert nichts in einer bestimmten Datenstruktur,

01:41:36.750 --> 01:41:40.710
sondern man erzeugt eine neue Kopie

01:41:40.710 --> 01:41:41.490
und

01:41:41.490 --> 01:41:44.870
an der ändert man dann halt

01:41:44.870 --> 01:41:46.830
irgendwas, beziehungsweise man ändert nichts, sondern

01:41:46.830 --> 01:41:48.170
man baut es dann halt neu.

01:41:51.110 --> 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.990
dass ich Sachen dann perfekt parallelisieren kann,

01:41:58.690 --> 01:42:00.610
dass ich 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.590
in Python imperativ macht, dass man irgendwie

01:42:12.590 --> 01:42:14.810
Attribute von irgendwelchen Objekten ändert oder

01:42:14.810 --> 01:42:16.750
halt irgendwie ein Dikt übergeben bekommt,

01:42:16.850 --> 01:42:18.550
das dann irgendwie dann ändert

01:42:18.550 --> 01:42:19.150
und dann

01:42:19.150 --> 01:42:22.510
würde man jetzt in funktionaler

01:42:22.510 --> 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.970
einen Dikt oder eine Liste oder sowas in der Funktion

01:42:30.970 --> 01:42:32.850
nehmen, da irgendwas dran ändern und das Ding

01:42:32.850 --> 01:42:34.770
dann wieder zurückgeben oder so oder am besten gar nicht

01:42:34.770 --> 01:42:35.970
zurückgeben, sondern einfach nur ändern,

01:42:36.810 --> 01:42:38.710
sondern man würde immer, wenn man was ändert,

01:42:38.710 --> 01:42:39.730
eine neue Kopie zurückgeben.

01:42:41.250 --> 01:42:42.870
Weil man dann halt diesen ganzen schönen Effekt

01:42:42.870 --> 01:42:44.730
hat, was, wenn man das nicht tut,

01:42:45.390 --> 01:42:46.770
was, würde ich sagen, aber in

01:42:46.770 --> 01:42:48.890
Python oft so ist, also man

01:42:48.890 --> 01:42:50.870
übergibt irgendwo eine Liste

01:42:50.870 --> 01:42:52.790
und dann ändert man irgendwie ein Element in dieser

01:42:52.790 --> 01:42:54.050
Liste und dann gibt man die Liste wieder zurück.

01:42:55.110 --> 01:42:56.690
Dann gehen ganz viele schöne Sachen

01:42:56.690 --> 01:42:58.450
nicht mehr, weil dann ist es halt,

01:42:58.870 --> 01:42:58.990
ja.

01:43:00.930 --> 01:43:02.610
Man hat vielleicht irgendwas kaputt gemacht.

01:43:03.070 --> 01:43:04.750
Ja. Was auf der anderen

01:43:04.750 --> 01:43:06.690
Seite manchmal halt auch total viel einfacher

01:43:06.690 --> 01:43:08.690
macht, als wenn man es funktional

01:43:08.690 --> 01:43:10.670
schreibt und auch effizienter,

01:43:10.770 --> 01:43:12.710
weil einmal ist es so, man kann halt

01:43:12.710 --> 01:43:14.230
Dinge nicht mehr so richtig direkt beeinflussen

01:43:14.230 --> 01:43:16.510
und es ist halt so, man muss halt,

01:43:16.650 --> 01:43:18.050
wenn man alles immer kopiert und jetzt

01:43:18.050 --> 01:43:20.210
man aber jetzt große Datenmengen hat, zum Beispiel

01:43:20.210 --> 01:43:22.790
im Data-Science-Bereich ist es halt, wenn deine Datenstrukturen

01:43:22.790 --> 01:43:24.610
alle hunderte Megabyte groß sind und du machst

01:43:24.610 --> 01:43:26.630
immer Kopien von allem, was auch,

01:43:27.050 --> 01:43:28.570
also tatsächlich, Pandas macht das auch

01:43:28.570 --> 01:43:30.490
per Default, wenn irgendwelche, alle

01:43:30.490 --> 01:43:31.850
Operationen geben immer Kopien zurück,

01:43:32.990 --> 01:43:34.770
aber das kann auch ganz schön in den Hauptspeicher

01:43:34.770 --> 01:43:36.590
gehen und manchmal muss man dann schon sagen, so, ja,

01:43:36.590 --> 01:43:38.630
hier bitte nicht kopieren. Das geht einfach nicht, passt da nicht

01:43:38.630 --> 01:43:39.710
mehr. Und dann

01:43:39.710 --> 01:43:41.330
muss man halt

01:43:41.330 --> 01:43:44.350
Sachen direkt in place

01:43:44.350 --> 01:43:46.670
ändern oder so. Und das ist natürlich immer ein bisschen schmutzig,

01:43:46.790 --> 01:43:47.470
aber ja.

01:43:47.990 --> 01:43:49.590
Weekend Dirty. Ja, ja.

01:43:50.370 --> 01:43:51.570
Dunkle Magie wieder.

01:43:52.950 --> 01:43:54.610
Ja, also hängt davon ab, würde ich sagen, was man

01:43:54.610 --> 01:43:56.570
für ein Problem hat. Und also

01:43:56.570 --> 01:43:58.570
wenn man das nicht kennt, dann sich mal so anzugucken,

01:43:58.650 --> 01:44:00.510
wie man mit alten Datenstrukturen einfach

01:44:00.510 --> 01:44:02.450
nur immutable irgendwie hält und immer

01:44:02.450 --> 01:44:04.450
kopieren soll. Das ist eigentlich schon sehr

01:44:04.450 --> 01:44:06.350
schick. Also dann kommen wir direkt

01:44:06.350 --> 01:44:08.710
das gekonnt, schließt 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.310
Hätte ich jetzt auch gesagt, früher fand ich Listen ganz toll Dict, aber

01:44:16.310 --> 01:44:18.490
ich auch, also vielleicht ein bisschen

01:44:18.490 --> 01:44:19.250
wo man gerade ist, ja.

01:44:20.090 --> 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.210 --> 01:44:25.030
Also die ist richtig schnell,

01:44:26.630 --> 01:44:28.550
die ist, ja, ist halt sehr effizientes

01:44:28.550 --> 01:44:30.470
Ding und einen Riesenhaufen

01:44:30.470 --> 01:44:32.130
Probleme lassen sich dadurch schon lösen.

01:44:32.130 --> 01:44:33.950
Also wenn man das ordentlich verwendet,

01:44:34.030 --> 01:44:36.050
dann kriegt man da so ein sehr

01:44:36.050 --> 01:44:37.990
großen Teil der so 0815

01:44:37.990 --> 01:44:40.050
Programmiergeschichten, die man so macht, kriegt man halt mit Listen

01:44:40.050 --> 01:44:41.050
und Dicts irgendwie abgebildet.

01:44:42.910 --> 01:44:43.810
Listen braucht man auch,

01:44:44.030 --> 01:44:46.070
halt gerade, wenn man irgendwelche Dinge iteriert

01:44:46.070 --> 01:44:48.070
und so, aber Dicts ist halt

01:44:48.070 --> 01:44:50.070
das Schöne daran ist, dass man halt irgendwie sozusagen

01:44:50.070 --> 01:44:51.970
beliebige Dinge irgendwie speichern kann

01:44:51.970 --> 01:44:53.610
und man kann die

01:44:53.610 --> 01:44:56.110
Namen, unter denen

01:44:56.110 --> 01:44:58.270
man das findet, dann halt irgendwie dynamisch generieren

01:44:58.270 --> 01:44:59.990
und muss das halt nicht vorher definiert haben

01:44:59.990 --> 01:45:00.330
in Code.

01:45:03.070 --> 01:45:04.190
Und wann nutzt

01:45:04.190 --> 01:45:05.970
man denn Tupel, das Datenschutz, wenn man eine Listen hat?

01:45:06.050 --> 01:45:06.910
Also warum ist das überhaupt?

01:45:07.250 --> 01:45:10.470
Ja, Tuppel sind halt immutable, ja genau.

01:45:11.370 --> 01:45:12.150
Das ist halt der Grund.

01:45:12.310 --> 01:45:16.250
Deswegen an den Stellen, wo man es halt immutable haben will,

01:45:16.370 --> 01:45:17.750
dann kann man die halt gut nehmen.

01:45:18.490 --> 01:45:20.490
Unter anderem zum Beispiel, wenn du halt möchtest,

01:45:20.610 --> 01:45:22.650
dass etwas Key in einem Dikt sein kann.

01:45:22.790 --> 01:45:23.790
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:31.750
Oder halt bei so Geschichten wie Tuppel, Unpacking und so,

01:45:32.030 --> 01:45:34.790
das geht auch nur mit Listen.

01:45:35.550 --> 01:45:37.530
Klar, das geht auch mit Listen, aber ich weiß nicht,

01:45:37.530 --> 01:45:38.970
ich überlege jetzt gerade, ob es einen tieferen Grund gibt,

01:45:39.090 --> 01:45:40.670
warum Argumente

01:45:40.670 --> 01:45:42.210
ein Doppel sind.

01:45:44.410 --> 01:45:44.590
Also,

01:45:44.950 --> 01:45:45.910
ja,

01:45:46.750 --> 01:45:49.530
generell. Also, Dicky war

01:45:49.530 --> 01:45:50.490
vielleicht eine gute Idee, ja.

01:45:51.490 --> 01:45:53.050
Es gibt schon

01:45:53.050 --> 01:45:55.390
den 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.390
statt eine Liste. Aber

01:45:59.390 --> 01:46:00.810
tatsächlich ist es so, es gibt auch

01:46:00.810 --> 01:46:03.310
Skalare, sozusagen einfache

01:46:03.310 --> 01:46:05.290
Werte irgendwie, also sowas wie eine 5

01:46:05.290 --> 01:46:13.490
oder wie String, wobei Listen und Dicts ist halt auch so das,

01:46:13.550 --> 01:46:15.010
was man in allen Programmiersprachen irgendwie

01:46:15.010 --> 01:46:16.730
oder vor allen Dingen in allen Skriptsprachen

01:46:16.730 --> 01:46:17.630
irgendwie eingebaut findet.

01:46:17.850 --> 01:46:20.250
Das hast du halt auch in Perl und in PHP und in JavaScript.

01:46:21.170 --> 01:46:23.650
Die heißen halt in allen diesen Programmiersprachen

01:46:23.650 --> 01:46:24.610
irgendwie ein bisschen anders.

01:46:24.830 --> 01:46:27.490
In Perl heißt es halt Hash und Array.

01:46:27.850 --> 01:46:31.610
In PHP heißt es Assoziatives Array.

01:46:33.290 --> 01:46:34.730
Und weiß ich nicht,

01:46:35.470 --> 01:46:37.050
JavaScript heißt es halt Object

01:46:37.050 --> 01:46:37.570
und

01:46:37.570 --> 01:46:40.550
ich glaube, da heißt es aber dann auch Array.

01:46:41.010 --> 01:46:42.550
Ja, naja. Aber

01:46:42.550 --> 01:46:45.110
diese Grunddatentypen hast du halt

01:46:45.110 --> 01:46:46.370
überall, deswegen, weil das halt,

01:46:46.830 --> 01:46:48.070
damit kannst du halt schon eine Menge machen.

01:46:48.770 --> 01:46:51.170
Und Tuple 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.810 --> 01:46:56.990
Ist halt schon eher so ein bisschen

01:46:56.990 --> 01:46:57.630
Spezialfall.

01:46:58.630 --> 01:47:01.110
Ja, es gibt auch

01:47:01.110 --> 01:47:02.650
oft von den ganzen

01:47:02.650 --> 01:47:07.490
also was auch mittlerweile, glaube ich, ein integrierter

01:47:07.490 --> 01:47:09.370
Datentyp ist, ist halt Z in Python.

01:47:10.170 --> 01:47:10.990
Ja. Das ist auch

01:47:10.990 --> 01:47:13.250
eine Datenstruktur, die wir relativ häufig

01:47:13.250 --> 01:47:14.830
oder ich benutze sie relativ häufig

01:47:14.830 --> 01:47:17.130
und von denen gibt es halt dann auch immutable

01:47:17.130 --> 01:47:19.230
Varianten. Ich weiß jetzt gar nicht, ob es immutable Dicts

01:47:19.230 --> 01:47:21.030
gibt, aber

01:47:21.030 --> 01:47:23.110
zum Beispiel von Z gibt es halt Frozen Z, eben

01:47:23.110 --> 01:47:25.050
auch für solche Fälle, wie du möchtest, dass das

01:47:25.050 --> 01:47:26.990
irgendwie als Key in Dict ist oder so.

01:47:28.010 --> 01:47:29.170
Und den kannst

01:47:29.170 --> 01:47:29.930
du halt dann nicht mehr verändern.

01:47:31.290 --> 01:47:33.430
Vielleicht gibt es auch so etwas wie eine Frozen-List, ich weiß nicht genau.

01:47:35.150 --> 01:47:35.510
Aber

01:47:35.510 --> 01:47:36.930
Frozen-Set benutze ich tatsächlich ab und zu.

01:47:37.030 --> 01:47:39.310
Frozen-List ist Tupel? Ja, könnte sein, genau.

01:47:39.470 --> 01:47:40.670
Frozen-List ist Tupel, ja, genau.

01:47:43.870 --> 01:47:45.390
Okay, wann nutzt man denn

01:47:45.390 --> 01:47:47.270
NumPy-Arrays? Ja,

01:47:47.370 --> 01:47:48.510
immer dann, wenn man halt

01:47:48.510 --> 01:47:50.310
sozusagen

01:47:50.310 --> 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.070 --> 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.150 --> 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 verschicken 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.490 --> 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.610
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.610 --> 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.190 --> 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.630
Rausschreibdinger

01:51:00.630 --> 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.610 --> 01:51:06.630
Es ist halt auch halbwegs sparsam,

01:51:06.730 --> 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.570 --> 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.730
Du kannst ja halt irgendwie auch definieren,

01:51:28.830 --> 01:51:29.830
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.670
reinschreibst, wann das okay ist.

01:51:34.750 --> 01:51:36.370
Du kannst halt eine DTD

01:51:36.370 --> 01:51:40.390
zu deinem XML

01:51:40.390 --> 01:51:42.450
dazuschreiben, das halt sozusagen definiert,

01:51:42.570 --> 01:51:44.790
wie das Format von deinem XML aussieht.

01:51:45.150 --> 01:51:46.530
Und dann kannst du das validieren dagegen

01:51:46.530 --> 01:51:46.870
und so.

01:51:48.070 --> 01:51:48.290
Ja.

01:51:53.290 --> 01:51:54.750
Ein heimlicher XML-Fan?

01:51:54.810 --> 01:51:54.990
Nein.

01:51:56.430 --> 01:52:23.970
Nein, das ist alles sehr schrecklich, also ich meine, man kann das machen, aber das ist alles, nee, es gibt auch einen Grund, warum das quasi niemand, also niemand tut, das ist einfach, das ist, ja, also in der Anfangszeit war das, also mittlerweile ist das auch alles nicht mehr so schlimm, es gibt gute Bibliotheken, aber es war schon nicht so einfach manchmal.

01:52:23.970 --> 01:52:25.990
Und was halt an XML nervtötend ist, ist halt, du kannst

01:52:25.990 --> 01:52:27.830
es als Mensch nicht gut lesen, es ist halt

01:52:27.830 --> 01:52:28.850
gigantisch groß.

01:52:30.090 --> 01:52:31.550
Hässlich. Hässlich, ja.

01:52:35.550 --> 01:52:37.950
Ja, und dann gibt es natürlich noch

01:52:37.950 --> 01:52:39.370
sowas wie Jammel oder so, heute

01:52:39.370 --> 01:52:41.470
so ein bisschen auch wieder en vogue.

01:52:42.670 --> 01:52:43.270
Auch hässlich.

01:52:43.270 --> 01:52:45.290
Ist aber auch ein bisschen hässlich,

01:52:45.390 --> 01:52:46.270
muss man leider sagen, ja.

01:52:48.090 --> 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.930 --> 01:52:52.930
das, was dabei rauskommt, wenn man

01:52:52.930 --> 01:52:54.890
irgendwie alle Fehler ignoriert,

01:52:54.950 --> 01:52:56.830
die bei Jason gemacht worden sind. Und Jason ist

01:52:56.830 --> 01:52:58.650
das, was rauskommt, wenn man alle Fehler ignoriert,

01:52:58.830 --> 01:53:00.410
die bei XML gemacht worden sind.

01:53:01.070 --> 01:53:02.710
Und die Geschichte

01:53:02.710 --> 01:53:03.850
wiederholt sich immer und immer wieder.

01:53:04.830 --> 01:53:06.570
Irgendwie das nächste Format heißt, was man nicht gebrauchen kann.

01:53:06.870 --> 01:53:08.350
Genau, das ist halt echt so ein, aber

01:53:08.350 --> 01:53:09.510
XML ist auch so ein bisschen,

01:53:10.130 --> 01:53:12.350
da wurde früher immer gespottet, dass man dem

01:53:12.350 --> 01:53:14.710
Format ansieht, dass es irgendwie von Juristen und nicht

01:53:14.710 --> 01:53:16.090
von Informatikern konzipiert wurde.

01:53:16.610 --> 01:53:18.570
Und dass man irgendwie solche Sachen nicht hat, wie

01:53:18.570 --> 01:53:20.790
also, du kannst es nicht ordentlich quoten.

01:53:22.190 --> 01:53:40.050
Wenn du jetzt zum Beispiel, du kannst halt innerhalb von XML, gibt es halt sowas wie Kommentare, wie willst du XML-Kommentare quoten? Das geht überhaupt gar nicht. Und das heißt, wenn du jetzt zum Beispiel in XML, in einem XML-Dokument beschreiben willst, wie denn jetzt XML auszusehen hat mit XML-Kommentaren, da passieren ganz schreckliche Sachen, das geht alles überhaupt gar nicht.

01:53:40.050 --> 01:54:03.250
Und es ist halt so, es kann doch nicht sein, dass daran keiner gedacht hat, dass das jetzt nicht geht. Es geht einfach nicht. Und ja, es ist nicht so, dass man sich sagt, das ist voll super elegant, total gut, nehmen wir jetzt sofort. Sondern es ist mehr so, oh, schrecklich. Und Jason ist aus dieser Perspektive für mich weniger schrecklich. Also es kann deutlich weniger. Aber okay, dafür ist es halt alles nicht so schlimm.

01:54:03.250 --> 01:54:05.470
Ist ja zum Serialisieren da, also dass man Daten irgendwo hinlegt

01:54:05.470 --> 01:54:07.050
als Pfeil oder sowas.

01:54:07.190 --> 01:54:09.210
Aber es gibt natürlich dann gewisse Begrenzungen,

01:54:09.330 --> 01:54:11.250
was halt dann nicht gut funktioniert.

01:54:11.870 --> 01:54:13.330
Eben, ja, Datum oder alles, was irgendwie

01:54:13.330 --> 01:54:15.310
komplizierte Objekte sind und Code kannst du da auch nicht

01:54:15.310 --> 01:54:17.270
mit reinpacken. Das geht

01:54:17.270 --> 01:54:18.890
alles nicht. Und

01:54:18.890 --> 01:54:21.210
auch dann für die Übertragung im Netz ist

01:54:21.210 --> 01:54:23.090
halt auch teilweise nicht so gut, weil das

01:54:23.090 --> 01:54:24.550
halt dann Text ist und

01:54:24.550 --> 01:54:26.910
das hat also bestimmte schlechte Eigenschaften.

01:54:27.830 --> 01:54:28.690
Du möchtest eigentlich,

01:54:29.030 --> 01:54:31.070
da gibt es dann sowas, da gibt es ein etwas besseres Format,

01:54:31.070 --> 01:54:32.890
Message Pack nennt sich das, das kann man halt so

01:54:32.890 --> 01:54:34.750
ähnlich wie Jason, bloß

01:54:34.750 --> 01:54:36.850
binär so, dass

01:54:36.850 --> 01:54:38.310
das halt irgendwie

01:54:38.310 --> 01:54:40.790
nicht kaputt gehen kann bei der Übertragung oder nicht so

01:54:40.790 --> 01:54:41.930
leicht kaputt gehen kann wie Jason.

01:54:43.170 --> 01:54:43.330
Ja,

01:54:43.690 --> 01:54:45.890
und naja,

01:54:46.570 --> 01:54:48.750
aber Jason ist eigentlich schon, würde ich sagen, für viele

01:54:48.750 --> 01:54:50.710
Fälle so das, was man eigentlich haben will

01:54:50.710 --> 01:54:52.730
und wenn es dann noch

01:54:52.730 --> 01:54:54.570
viel komplizierter wird, kann man auch sowas nehmen wie Pickle,

01:54:54.630 --> 01:54:55.270
da muss man aufpassen.

01:54:56.570 --> 01:54:57.770
Es gibt noch in

01:54:57.770 --> 01:55:00.730
Python selber, wenn ich jetzt überlege,

01:55:00.810 --> 01:55:02.430
gibt es noch eingebaute Geschichten, es gibt noch

01:55:02.430 --> 01:55:04.550
Marshall das Modul ist, macht sowas ähnliches wie

01:55:04.550 --> 01:55:06.330
JSON, bloß halt

01:55:06.330 --> 01:55:08.030
binär. Das ist auch ein Stückchen schneller.

01:55:09.190 --> 01:55:10.350
Und dann gibt es noch Shelf,

01:55:10.490 --> 01:55:12.410
glaube ich. Das weiß ich aber nicht. Das habe ich schon ganz lange

01:55:12.410 --> 01:55:13.130
nicht mehr verwendet.

01:55:14.530 --> 01:55:16.530
Und eben, wenn man jetzt aber nicht nur

01:55:16.530 --> 01:55:17.370
Daten

01:55:17.370 --> 01:55:20.330
serialisieren will, sondern vielleicht auch Code

01:55:20.330 --> 01:55:22.670
mit, also komplette Objekte mit Funktionalität,

01:55:23.890 --> 01:55:24.190
dann

01:55:24.190 --> 01:55:25.930
ja sowas wie Pickle.

01:55:26.210 --> 01:55:27.870
Und Pickle kann man auch schicken als binär-File.

01:55:27.870 --> 01:55:29.510
Genau, man kann

01:55:29.510 --> 01:55:31.890
verwandelt halt ein komplettes Objekt

01:55:31.890 --> 01:55:33.770
zum Beispiel in einen Binären-String

01:55:33.770 --> 01:55:35.590
und dann schickt man den irgendwie übers 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.890 --> 01:55:45.970
dass man, dann führt der Code aus.

01:55:46.190 --> 01:55:46.610
Also wenn

01:55:46.610 --> 01:55:49.570
einem jemand irgendwie, der nicht

01:55:49.570 --> 01:55:51.650
vertrauenswürdig ist, halt irgendwie

01:55:51.650 --> 01:55:53.550
irgendwas Gepickeltes schickt, da kann

01:55:53.550 --> 01:55:55.590
beliebiger Code drin sein.

01:55:55.810 --> 01:55:57.630
Also wenn man das anpickelt, dann

01:55:57.630 --> 01:55:58.910
führt man das aus, was da drin steht.

01:55:59.810 --> 01:56:00.870
Das heißt, ja, das sollte

01:56:00.870 --> 01:56:03.130
das sollte man sich

01:56:03.130 --> 01:56:03.990
klar machen, dass das...

01:56:03.990 --> 01:56:07.010
Genau, dass man

01:56:07.010 --> 01:56:08.550
also, ja, irgendwas

01:56:08.550 --> 01:56:10.990
anpickeln,

01:56:11.230 --> 01:56:12.810
was einem jemand gibt, ist so wie irgendwie

01:56:12.810 --> 01:56:14.090
Code ausführen, die einem jemand gibt.

01:56:14.590 --> 01:56:16.770
Ein Paket öffnen, was man nach Hause geschickt bekommen hat, da kann auch

01:56:16.770 --> 01:56:18.790
eine Briefbombe drin sein, man weiß es nie so genau.

01:56:20.190 --> 01:56:20.990
Das ist immer auch beim Essen,

01:56:21.050 --> 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ß es nie so genau.

01:56:28.690 --> 01:56:30.770
Die Paranoia kann ja beliebig weit getrieben

01:56:30.770 --> 01:56:32.130
werden. Genau, genau, genau.

01:56:32.790 --> 01:56:34.530
Pickel, lass mal überlegen, gibt es noch, es gibt

01:56:34.530 --> 01:56:36.510
dann noch diverse, es gibt dann noch

01:56:36.510 --> 01:56:38.510
für den wissenschaftlichen Bereich ein paar Sachen, es gibt noch

01:56:38.510 --> 01:56:39.410
HDF5,

01:56:40.210 --> 01:56:42.570
Net, wie heißt das Ding, NetCD,

01:56:44.370 --> 01:56:45.390
ich habe es jetzt wieder vergessen,

01:56:46.690 --> 01:56:48.450
wie der Standard ist,

01:56:48.670 --> 01:56:50.450
also wie, ja, es gibt so eben für

01:56:50.450 --> 01:56:52.690
wissenschaftliche Daten, gibt es noch Standards,

01:56:52.850 --> 01:56:54.470
wie man, wie man

01:56:54.470 --> 01:56:56.350
Sachen speichert, die noch so ein bisschen anders sind.

01:56:58.350 --> 01:56:59.570
Eine CDF, glaube ich, ist das.

01:57:00.190 --> 01:57:01.730
Und HDF5 ist einer der,

01:57:02.530 --> 01:57:04.370
das gehört da irgendwie mit rein in diese Reihenfolge.

01:57:04.430 --> 01:57:05.690
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.350
NumPy-Arrays haben auch

01:57:10.350 --> 01:57:12.470
nochmal eine eigene Möglichkeit, wie man sie serialisieren kann.

01:57:13.070 --> 01:57:14.270
Man kann die auch Memory-Mappen

01:57:14.270 --> 01:57:16.150
ähm,

01:57:17.090 --> 01:57:18.110
ja, oder ich meine, CSV

01:57:18.110 --> 01:57:19.710
ist auch eine Möglichkeit, Sachen zu serialisieren.

01:57:19.790 --> 01:57:20.930
CSV ist auch wieder so ein Format,

01:57:21.670 --> 01:57:24.070
so eigene, fürchterliche, schreckliche Sachen

01:57:24.070 --> 01:57:24.610
mit sich bringen.

01:57:25.850 --> 01:57:27.870
Aber, äh, also

01:57:27.870 --> 01:57:29.930
in anderer Sicht ist es auch

01:57:29.930 --> 01:57:31.130
wieder ganz gut. Also oft

01:57:31.130 --> 01:57:33.810
würde ich sagen, wenn man die Wahl hat

01:57:33.810 --> 01:57:35.790
zwischen CSV und XML, ist CSV die bessere

01:57:35.790 --> 01:57:37.330
Wahl. Aber

01:57:37.330 --> 01:57:38.590
ja.

01:57:40.930 --> 01:57:41.290
Tja.

01:57:42.350 --> 01:57:43.810
Ja, aber das war es

01:57:43.810 --> 01:57:45.630
im Grunde eigentlich. Haben wir noch eine wichtige

01:57:45.630 --> 01:57:47.470
Serialisierungsgeschichte? Ja, ich glaube,

01:57:47.550 --> 01:57:49.450
wir wollen ja auch, eigentlich wollen wir ja nur eine Minute reden.

01:57:49.530 --> 01:57:50.450
Ich glaube, das halten wir jetzt.

01:57:50.650 --> 01:57:53.530
Ja, ich habe jetzt noch so ein paar Themen, die sind

01:57:53.530 --> 01:57:55.170
irgendwie jetzt alle aber sehr unzusammenhängend auch.

01:57:55.810 --> 01:57:57.710
Ich überlege gerade, wo ich damit jetzt noch anfangen

01:57:57.710 --> 01:57:59.670
soll. Ich glaube, am Memory Management hatten wir schon mal

01:57:59.670 --> 01:58:01.570
gesprochen, ich glaube, in einer der ersten Folgen, da haben wir ja über den JIT

01:58:01.570 --> 01:58:03.510
und den GIL gesprochen, an den

01:58:03.510 --> 01:58:05.290
Just-in-Time-Compiler und den

01:58:05.290 --> 01:58:06.510
Interpreter-Log.

01:58:07.850 --> 01:58:09.610
Dann habe ich jetzt noch das Konzept von

01:58:09.610 --> 01:58:11.750
MapReduce, aber ich weiß nicht, ob das jetzt hier zugehört,

01:58:11.850 --> 01:58:12.850
dass das irgendwie nicht ganz...

01:58:12.850 --> 01:58:15.610
Es ist auch so ein bisschen veraltet, also inzwischen macht das

01:58:15.610 --> 01:58:17.270
keiner mehr. Und dann, was

01:58:17.270 --> 01:58:19.610
mich aber natürlich noch interessiert, wenn man halt debuggen

01:58:19.610 --> 01:58:21.610
möchte, was da irgendwie der Zeug ist, dann

01:58:21.610 --> 01:58:23.270
gibt es irgendwie so ein bisschen, ich nenne es jetzt mal

01:58:23.270 --> 01:58:24.810
Deep-Debugging, das heißt, man kann

01:58:24.810 --> 01:58:26.570
Deer auf irgendwelche

01:58:26.570 --> 01:58:28.830
Spawn oder Help aufrufen und so, was

01:58:28.830 --> 01:58:30.890
gibt es denn da noch und wie würde man sich dann angucken,

01:58:30.970 --> 01:58:32.830
was überhaupt möglich ist mit so Objekten, die

01:58:32.830 --> 01:58:34.850
man da zurückbekommt, wo man

01:58:34.850 --> 01:58:36.230
nicht genau weiß, woran liegt denn das jetzt,

01:58:36.730 --> 01:58:38.750
guckt man dann da genauer rein. Naja, ich glaube, das ist schon,

01:58:39.170 --> 01:58:40.750
also Help zeigt halt den...

01:58:40.750 --> 01:58:42.730
Also was macht man, Help ist eine Funktion, die man

01:58:42.730 --> 01:58:44.370
außen rum schmeißt und was, was zurückkommt, oder?

01:58:45.430 --> 01:58:46.110
Ja, aber das,

01:58:46.770 --> 01:58:48.810
also an den Objekten hängen halt auch immer Dinge

01:58:48.810 --> 01:58:51.010
dran, also zum Beispiel man an dem Funktionsobjekt

01:58:51.010 --> 01:58:52.590
hängt halt auch immer die Dokumentation, also

01:58:52.590 --> 01:58:54.750
der Dockstring hängt da halt mit dran, den man sich dann angucken kann.

01:58:54.810 --> 01:58:57.190
Und ich weiß nicht genau, was Help macht, aber Help, glaube ich,

01:58:57.210 --> 01:58:58.430
wird sowas tun, wie

01:58:58.430 --> 01:59:00.510
die Dockstrings nehmen und anzeigen.

01:59:00.930 --> 01:59:01.350
Mehr oder weniger.

01:59:03.050 --> 01:59:04.850
Und dir zeigt halt alle

01:59:04.850 --> 01:59:06.990
Attribute und Methoden oder so

01:59:06.990 --> 01:59:08.930
an einem Objekt, die da so

01:59:08.930 --> 01:59:10.990
dranhängen und dann

01:59:10.990 --> 01:59:11.630
ja,

01:59:12.810 --> 01:59:14.970
zumindest kann man sich dann, zeigt es auch

01:59:14.970 --> 01:59:16.930
die Funktion Signature, glaube ich, an noch.

01:59:17.690 --> 01:59:18.390
Was gibt es denn noch?

01:59:19.330 --> 01:59:21.090
Mehr verwende ich eigentlich auch

01:59:21.090 --> 01:59:22.050
praktisch nicht.

01:59:23.890 --> 01:59:24.670
Die ist MRO, ne?

01:59:24.670 --> 01:59:26.830
dieses Basis, also wenn man so eine von diesen Objekten,

01:59:26.930 --> 01:59:28.730
die man mit dir dann rausbekommt, sich anguckt,

01:59:29.150 --> 01:59:30.590
dann bekommt man natürlich noch viel mehr Informationen,

01:59:30.750 --> 01:59:32.670
weil diese ganzen Magic Methods,

01:59:32.750 --> 01:59:34.710
Meta-Attribute irgendwie von den Klassen dran hängen,

01:59:35.150 --> 01:59:36.690
dass man zum Beispiel jetzt mit Basis

01:59:36.690 --> 01:59:38.610
sehen kann, welche Oberklassen

01:59:38.610 --> 01:59:40.210
hat denn überhaupt das Ding, wo ich dann drin bin.

01:59:40.250 --> 01:59:42.010
Ah, okay, cool. 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.470
MRO, also diese Method Resolution Order,

01:59:48.570 --> 01:59:50.850
zeigt dann vielleicht genau, welches von den

01:59:50.850 --> 01:59:53.630
Dingen aufgerufen worden ist,

01:59:53.630 --> 01:59:55.730
von den Methoden, die man jetzt in reiner Weise überschrieben hat

01:59:55.730 --> 01:59:57.570
und was da eigentlich hinter steckt, damit man vielleicht

01:59:57.570 --> 01:59:59.550
weiß, oh, es wurde etwas Falsches aufgerufen. Also so

01:59:59.550 --> 02:00:01.570
kann man so ein bisschen immer gucken, wenn irgendwas schief geht,

02:00:01.630 --> 02:00:03.550
wo man überhaupt nicht weiß, was man da gemacht hat, dass man

02:00:03.550 --> 02:00:04.650
nicht mehr irgendeinen Komma vergessen hat,

02:00:05.650 --> 02:00:07.490
wie man dann da reinkommt. Wobei da dann vielleicht

02:00:07.490 --> 02:00:09.750
auch eine bessere Wahl wäre,

02:00:09.850 --> 02:00:10.890
einfach direkt einen

02:00:10.890 --> 02:00:13.030
Debugger zu verwenden.

02:00:13.730 --> 02:00:15.150
Ja, welchen würdest du da empfehlen?

02:00:15.450 --> 02:00:17.390
PDB ist halt so das, was, und man kann ja auch

02:00:17.390 --> 02:00:19.430
inzwischen... Was macht PDB? Also der stoppt

02:00:19.430 --> 02:00:21.510
den Code zur Ausführzeit, man hat eine Shell

02:00:21.510 --> 02:00:22.030
und kann dann da hochgehen.

02:00:22.030 --> 02:00:23.530
Du kannst halt auch irgendwie, genau,

02:00:24.530 --> 02:00:25.450
im Code halt rein,

02:00:25.990 --> 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 du halt einfach deinen Code rein

02:00:32.130 --> 02:00:33.710
und dann hast du da halt ein,

02:00:33.710 --> 02:00:35.390
stoppt halt die

02:00:35.390 --> 02:00:37.790
Ausführungen an der Stelle und du hast halt,

02:00:37.890 --> 02:00:40.090
kriegst halt ein interaktives Prompt, an dem du halt gucken kannst,

02:00:40.150 --> 02:00:41.530
was steht denn zum Beispiel in den Variablen drin

02:00:41.530 --> 02:00:44.150
und dann kannst du halt auch sagen, okay, ich gehe jetzt hier

02:00:44.150 --> 02:00:45.950
weiter oder ich überspringe das und

02:00:45.950 --> 02:00:47.830
gucke dann wieder, was ist denn da los und

02:00:47.830 --> 02:00:50.070
genau, also und dann

02:00:50.070 --> 02:00:51.210
weißt du ja genau, wo du bist

02:00:51.210 --> 02:00:54.010
also das ist

02:00:54.010 --> 02:00:55.850
eine schöne Geschichte, ich weiß jetzt nicht, wann das

02:00:55.850 --> 02:00:57.930
eingebaut ist, seit wann das Tracing

02:00:57.930 --> 02:00:59.330
eingebaut ist, das müsste jetzt auch irgendwann,

02:00:59.550 --> 02:01:01.030
das ist noch nicht so lange her, glaube ich.

02:01:01.750 --> 02:01:04.190
Ja, aber Debugger

02:01:04.190 --> 02:01:05.490
hilft einem da schon

02:01:05.490 --> 02:01:07.170
deutlich, ja.

02:01:07.890 --> 02:01:09.810
Funktioniert halt auch in Django oder so,

02:01:10.770 --> 02:01:12.070
kriegt man das über die Webseite

02:01:12.070 --> 02:01:13.330
halt dann entsprechend schnell.

02:01:13.430 --> 02:01:15.730
Ich glaube, das gehört auch mit der VSCode, also der Enito, der hat das irgendwie auch

02:01:15.730 --> 02:01:17.090
implementiert. Ja, das muss ich mir auch nochmal angucken.

02:01:17.750 --> 02:01:19.770
Gar nicht richtig genutzt, man kann halt

02:01:19.770 --> 02:01:21.630
dann so Debug-Stops setzen und so.

02:01:22.710 --> 02:01:23.890
Ja, Breakpoints.

02:01:24.130 --> 02:01:24.870
Introspection, ja genau.

02:01:26.610 --> 02:01:27.810
Ja, ich habe jetzt noch

02:01:27.810 --> 02:01:29.490
zwei andere wieder. Punkt drauf, die nicht mehr zu tun.

02:01:29.550 --> 02:01:31.590
Zwar einmal, wie löst man Multithreading in Python?

02:01:32.910 --> 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.950
Also tatsächlich sind auch Threads in Python

02:01:37.950 --> 02:01:39.790
halt tatsächlich ganz normale, bilden

02:01:39.790 --> 02:01:41.970
sich ab auf Threads im Betriebssystem.

02:01:44.530 --> 02:01:45.750
Es ist halt nur so, dass

02:01:45.750 --> 02:01:47.590
die nicht wirklich

02:01:47.590 --> 02:01:49.250
parallel Dinge tun können.

02:01:49.770 --> 02:01:52.070
unterschiedlichen CPUs sozusagen. Sie können schon

02:01:52.070 --> 02:01:54.110
parallel Sachen machen, aber halt natürlich dann

02:01:54.110 --> 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.910
man benutzt die aber,

02:02:10.430 --> 02:02:12.050
also daher kann man sie nicht dafür

02:02:12.050 --> 02:02:13.090
verwenden, um

02:02:13.090 --> 02:02:16.050
Berechnungen zu parallelisieren,

02:02:16.150 --> 02:02:18.130
weil eben dafür müsste man es ja auf Prozessoren aufteilen

02:02:18.130 --> 02:02:19.510
können. Das geht nicht.

02:02:19.770 --> 02:02:22.310
Aber um I.O.

02:02:22.390 --> 02:02:24.030
zu multiplexen, geht das

02:02:24.030 --> 02:02:25.710
ganz hervorragend und das

02:02:25.710 --> 02:02:28.030
funktioniert gut, kann man dafür

02:02:28.030 --> 02:02:28.470
benutzen.

02:02:29.830 --> 02:02:31.270
Ist jetzt nicht so die

02:02:31.270 --> 02:02:34.290
moderne Art, das zu tun.

02:02:35.630 --> 02:02:36.290
Da würde man

02:02:36.290 --> 02:02:38.130
wahrscheinlich eher sowas wie Async I.O. nehmen oder so.

02:02:39.030 --> 02:02:40.230
Aber man kann

02:02:40.230 --> 02:02:41.990
auch ZSATs benutzen, ist völlig

02:02:41.990 --> 02:02:44.170
okay. Also Async I.O. macht dann echt

02:02:44.170 --> 02:02:46.070
das Multithreading auf Multiprozessor? Nein, das macht kein

02:02:46.070 --> 02:02:47.950
Threading. Async I.O. ist wieder eine andere

02:02:47.950 --> 02:02:49.830
Geschichte. Was ist das? Async.io

02:02:49.830 --> 02:02:51.650
ist, ja,

02:02:52.550 --> 02:02:54.170
kann man sagen, einmal eine Event-Loop,

02:02:54.890 --> 02:02:55.870
sozusagen so ähnlich wie

02:02:55.870 --> 02:02:57.070
in Node.js oder so auch,

02:02:58.210 --> 02:02:59.770
wo halt immer geguckt wird, was gibt es denn jetzt

02:02:59.770 --> 02:03:01.690
gerade zu tun oder so, und dann macht man halt an einer bestimmten Stelle

02:03:01.690 --> 02:03:03.050
weiter. Aber

02:03:03.050 --> 02:03:05.910
vor allen Dingen halt auch eine Syntax, wie man das

02:03:05.910 --> 02:03:08.230
so hinschreibt, dass das automatisch

02:03:08.230 --> 02:03:09.810
gehandelt

02:03:09.810 --> 02:03:11.330
werden kann. Also ich kann halt

02:03:11.330 --> 02:03:13.750
sozusagen in Python Funktionen

02:03:13.750 --> 02:03:14.950
als Async deklarieren

02:03:14.950 --> 02:03:17.570
und dann kann ich halt

02:03:17.570 --> 02:03:19.730
die Ausführungen, wenn die zum Beispiel

02:03:19.730 --> 02:03:21.550
blockieren, halt unterbrechen. Die werden dann später weiter

02:03:21.550 --> 02:03:23.190
ausgeführt, wenn es halt wieder was zu tun gibt.

02:03:24.690 --> 02:03:24.750
Und

02:03:24.750 --> 02:03:26.270
ja,

02:03:26.830 --> 02:03:28.950
das

02:03:28.950 --> 02:03:31.710
aber das müssten wir, wenn man das

02:03:31.710 --> 02:03:33.170
wirklich erklären will, wie das funktioniert,

02:03:33.270 --> 02:03:34.350
eine Folge zu machen,

02:03:35.310 --> 02:03:37.450
eben, damit kann man halt auch

02:03:37.450 --> 02:03:38.410
IO multiplexen

02:03:38.410 --> 02:03:41.550
und das Ganze in einer etwas

02:03:41.550 --> 02:03:43.650
intuitiveren Art hinschreiben, als wenn man

02:03:43.650 --> 02:03:45.550
das jetzt mit Threading machen würde. Weil wenn man das mit Threading

02:03:45.550 --> 02:03:48.750
Modul macht, dann wird es sehr schnell

02:03:48.750 --> 02:03:50.770
auch sehr unintuitiv

02:03:50.770 --> 02:03:52.690
und was man auch irgendwie dabei

02:03:52.690 --> 02:03:55.030
beachten muss, ist halt, wenn man

02:03:55.030 --> 02:03:57.250
Tracebacks

02:03:57.250 --> 02:03:58.710
kriegt irgendwo in

02:03:58.710 --> 02:04:00.710
Workern, die halt in unterschiedlichen Threads laufen,

02:04:00.870 --> 02:04:02.650
das kann sehr, also

02:04:02.650 --> 02:04:04.750
das ist halt sowieso das Problem,

02:04:04.850 --> 02:04:06.590
wenn man jetzt irgendwie Dinge asynchron tut

02:04:06.590 --> 02:04:08.090
oder so, die halt so irgendwie

02:04:08.090 --> 02:04:10.490
man hat nicht mehr so

02:04:10.490 --> 02:04:11.470
wirklich einen linearen,

02:04:12.390 --> 02:04:14.170
der Code läuft nicht mehr so linear durch, sondern

02:04:14.170 --> 02:04:16.290
man weiß halt nie so genau, wo man gerade ist

02:04:16.290 --> 02:04:18.250
und was da gerade passiert. Und wenn man da

02:04:18.250 --> 02:04:20.190
Tracebacks kriegt und viele

02:04:20.190 --> 02:04:22.390
Threads verwendet, dann weiß man

02:04:22.390 --> 02:04:24.430
manchmal echt gar nicht, was da gerade passiert ist.

02:04:24.850 --> 02:04:26.270
Manchmal kommt man in Zuständen raus, die sehr

02:04:26.270 --> 02:04:28.270
eigenartig sind und das ist dann immer sehr hässlich

02:04:28.270 --> 02:04:30.230
zu debuggen. Und das geht

02:04:30.230 --> 02:04:32.270
mit Async.io deutlich besser.

02:04:32.430 --> 02:04:34.290
Also es ist halt deutlich eher so,

02:04:34.450 --> 02:04:36.510
dass man Code so hinschreibt,

02:04:36.650 --> 02:04:38.050
als wäre er synchron quasi,

02:04:38.530 --> 02:04:40.250
aber er dann halt automatisch

02:04:40.250 --> 02:04:41.730
mehr oder weniger Async. Also

02:04:41.730 --> 02:04:59.610
So ist das halt in den Stellen, wo man auf einen Syscall wartet oder so, wo es blockiert, da macht man halt an einer anderen Stelle, wo man halt weitermachen kann, weiter. Und erst dann, wenn dann irgendein Read von irgendwie Netzwerkgeschichte zurückkommt, dann geht es halt dann da wieder weiter.

02:05:01.210 --> 02:05:03.030
Ja, also insofern würde ich sagen,

02:05:03.190 --> 02:05:04.710
also wenn man jetzt erst damit anfängt,

02:05:04.830 --> 02:05:06.810
dann ist Async.io wahrscheinlich die interessantere

02:05:06.810 --> 02:05:08.830
Geschichte, die man sich angucken sollte, weil es

02:05:08.830 --> 02:05:10.910
mehr aussieht wie ein normales

02:05:10.910 --> 02:05:12.790
Programm. Aber

02:05:12.790 --> 02:05:14.590
Threading kann man durchaus auch machen

02:05:14.590 --> 02:05:16.850
und ist wahrscheinlich sogar ein bisschen schneller,

02:05:16.930 --> 02:05:17.850
wenn man wenig Threads hat.

02:05:18.790 --> 02:05:20.610
Aber ach, das ist eigentlich auch furchtbar, das spielt

02:05:20.610 --> 02:05:21.270
keine große Rolle.

02:05:23.250 --> 02:05:24.770
Ja, dann was ist Coverage?

02:05:27.970 --> 02:05:28.630
Ganz anders.

02:05:30.630 --> 02:05:32.710
Ja, meinst du das Paket oder das Modul?

02:05:33.110 --> 02:05:34.850
Achso, die Coverage, ja, sozusagen wie viel

02:05:34.850 --> 02:05:38.610
ja, damit

02:05:38.610 --> 02:05:40.730
gibt man sozusagen an, wie viel Prozent

02:05:40.730 --> 02:05:41.550
des

02:05:41.550 --> 02:05:44.550
Codes durchlaufen wird,

02:05:44.750 --> 02:05:46.290
den man geschrieben hat, wenn man die Tests

02:05:46.290 --> 02:05:47.870
also man kann ja halt gucken,

02:05:48.430 --> 02:05:49.690
das geht natürlich in Python ganz gut,

02:05:50.110 --> 02:05:51.670
es gibt auch ein Modul-Coverage-PUI,

02:05:52.250 --> 02:05:54.430
das das macht, das halt guckt, wie viele

02:05:54.430 --> 02:05:56.410
von den Zeilen wurden denn aufgerufen,

02:05:57.230 --> 02:05:58.610
wenn ich jetzt die Tests durchlaufen lasse

02:05:58.610 --> 02:06:00.510
von meinem Gesamtding und das dann halt sozusagen

02:06:00.510 --> 02:06:02.290
die Coverage ist halt sozusagen die Prozentzahl.

02:06:02.430 --> 02:06:04.390
Wenn ich halt 70 Prozent habe, dann ist es halt

02:06:04.390 --> 02:06:06.590
besser, als wenn

02:06:06.590 --> 02:06:08.530
ich 50 Prozent habe. Wie viel sollte man denn

02:06:08.530 --> 02:06:10.070
davon haben? Es gibt Leute, die sagen,

02:06:10.130 --> 02:06:12.250
100 Prozent haben. 150?

02:06:13.390 --> 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:16.950 --> 02:06:18.490
weil es dann manche Sachen

02:06:18.490 --> 02:06:19.730
sind einfach schwer zu testen und

02:06:19.730 --> 02:06:22.630
irgendwann wird es halt dann

02:06:22.630 --> 02:06:24.310
sehr aufwendig und also

02:06:24.310 --> 02:06:26.390
die ersten 80 Prozent sind

02:06:26.390 --> 02:06:28.390
wie das so immer ist, die gehen relativ

02:06:28.390 --> 02:06:29.810
einfach und dann die letzten 20 Prozent

02:06:29.810 --> 02:06:32.450
brauchen dann nochmal 80%

02:06:32.450 --> 02:06:34.070
der Zeit irgendwie, weil

02:06:34.070 --> 02:06:36.330
das dann halt alles so fiese Fälle sind, die man nicht gut testen kann.

02:06:36.950 --> 02:06:38.310
Und dann ist halt die Frage, ist es noch sinnvoll,

02:06:38.390 --> 02:06:40.410
da so viel Zeit reinzustecken, weil den größten

02:06:40.410 --> 02:06:41.990
Nutzen hat man dann vielleicht schon gehabt,

02:06:42.230 --> 02:06:43.110
irgendwie in dem

02:06:43.110 --> 02:06:45.930
Code, der halt einfach zu testen war.

02:06:46.330 --> 02:06:48.190
Aber auch da kann man das natürlich

02:06:48.190 --> 02:06:50.210
vereinfachen, indem man Code so schreibt, dass man ihn einfach

02:06:50.210 --> 02:06:51.950
testen kann. Also manchmal mache ich Funktionen,

02:06:51.990 --> 02:06:53.950
schreibe ich Funktionen nur deswegen, um

02:06:53.950 --> 02:06:56.290
diese Funktionen einzeln

02:06:56.290 --> 02:06:56.970
testen zu können.

02:06:58.270 --> 02:07:06.730
Und ja, oder manchmal macht es Sinn, Dinge auf eine bestimmte Art zu strukturieren, sodass man sie halt leichter testen kann, als wenn man jetzt irgendwie alles in einer Funktion hat oder so.

02:07:06.770 --> 02:07:08.050
Dann ist halt einfach schwer, die zu testen.

02:07:09.610 --> 02:07:12.350
Ja, und möglichst hohe Coverage ist natürlich gut.

02:07:12.350 --> 02:07:17.450
Also ich bin jetzt nicht so, ich will jetzt nicht sagen, dass 100% unbedingt notwendig ist, aber viel wäre schon gut.

02:07:18.870 --> 02:07:24.970
Und dann gibt es natürlich nochmal auch feine Unterschiede, ob man jetzt nur irgendwie durch den Code durchgelaufen ist.

02:07:25.250 --> 02:07:27.070
hat man aber auch wirklich alle, gibt's

02:07:27.070 --> 02:07:29.070
für jede unterschiedliche, also

02:07:29.070 --> 02:07:30.190
wenn man sowas wie

02:07:30.190 --> 02:07:33.650
Condition, so If-Else

02:07:33.650 --> 02:07:35.030
Geschichten hat, werden auch wirklich,

02:07:35.450 --> 02:07:36.970
hat man sichergestellt, dass man alle Branches,

02:07:37.090 --> 02:07:38.990
die dann passieren können, durchlaufen hat und so.

02:07:39.450 --> 02:07:41.150
Insofern ist nicht mehr so ganz klar, was

02:07:41.150 --> 02:07:42.550
gemeint ist, wenn man jetzt Coverage sagt.

02:07:43.430 --> 02:07:45.150
Und ja, das kann

02:07:45.150 --> 02:07:46.830
man dann auch nochmal, also

02:07:46.830 --> 02:07:49.010
ich glaube, die ursprüngliche Geschichte ist nur

02:07:49.010 --> 02:07:50.870
so, es ist egal, es müssen nicht alle

02:07:50.870 --> 02:07:51.870
Branches durchlaufen werden.

02:07:53.210 --> 02:07:55.030
Und das will man vielleicht auch anders haben.

02:07:55.190 --> 02:07:57.010
Also ich glaube, das kann man auch bei Coverage noch einstellen.

02:07:58.530 --> 02:07:59.130
Etwas feiner.

02:07:59.350 --> 02:08:00.310
Aber ja, genau.

02:08:00.470 --> 02:08:02.390
Das Test-Coverage ist halt sozusagen ein Maß dafür,

02:08:02.510 --> 02:08:06.570
wie viel von dem Code, der in deiner Bibliothek ist oder so,

02:08:06.630 --> 02:08:09.470
wie viel davon ist eigentlich durch Tests überprüft

02:08:09.470 --> 02:08:13.070
oder ist überhaupt mal ausgeführt worden bei einem Test.

02:08:16.170 --> 02:08:17.990
Ja, dann haben wir fast ja schon die letzte Frage.

02:08:18.090 --> 02:08:20.110
Ich glaube, wir sind da schon ziemlich lange wieder heute dabei.

02:08:20.610 --> 02:08:23.170
Und zwar auch wieder eine Hörerfrage.

02:08:23.650 --> 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:31.830 --> 02:08:32.670
Ja, also

02:08:32.670 --> 02:08:37.150
was ich oft mache, ist tatsächlich,

02:08:37.470 --> 02:08:39.250
aber ich meine, es ist ja die Frage, wann das Sinn

02:08:39.250 --> 02:08:41.050
macht. Das macht eigentlich erst dann Sinn, wenn man

02:08:41.050 --> 02:08:42.330
viel Hauptspeicher verbraucht.

02:08:42.990 --> 02:08:45.090
Und ich mache das tatsächlich oft so,

02:08:45.270 --> 02:08:46.490
dass ich einfach mir

02:08:46.490 --> 02:08:49.270
die Ausgabe von Top angucke.

02:08:50.250 --> 02:08:50.990
Und dann sehe ich schon

02:08:50.990 --> 02:08:53.150
Systemausgabe, wie viel Speicher

02:08:53.150 --> 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.130 --> 02:08:59.250
und wenn dann halt irgendwas

02:08:59.250 --> 02:09:01.210
läuft, dann weiß ich ungefähr, wie viel

02:09:01.210 --> 02:09:03.090
Speicher das verbrauchen sollte. Und wenn das

02:09:03.090 --> 02:09:04.910
doppelt oder dreimal so viel verbraucht, dann

02:09:04.910 --> 02:09:07.170
weiß ich, dass ich da ein Problem habe

02:09:07.170 --> 02:09:08.230
und vielleicht nochmal irgendwas machen muss.

02:09:09.370 --> 02:09:10.690
Es gibt aber auch systematische

02:09:10.690 --> 02:09:13.170
Ansätze. Also es gibt zum Beispiel

02:09:13.170 --> 02:09:14.570
auch eingebauten Profiler

02:09:14.570 --> 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:21.050
Genau. Das kann aber

02:09:21.050 --> 02:09:22.590
mit Memory-Geschichten nicht so viel machen.

02:09:23.150 --> 02:09:25.370
für Memory-Sachen, glaube ich,

02:09:25.610 --> 02:09:26.570
da nimmt man dann eher so ein bisschen

02:09:26.570 --> 02:09:29.070
K-Cache-Grind oder sowas, aber das ist,

02:09:29.390 --> 02:09:31.050
ich hab das...

02:09:31.050 --> 02:09:33.570
Aber wenn man das jetzt im Jupyter-Notebook machen möchte, weil man jetzt keinen Pop hat

02:09:33.570 --> 02:09:35.310
oder sowas und... Naja, du kannst dir halt

02:09:35.310 --> 02:09:37.570
von den Datenstrukturen anzeigen

02:09:37.570 --> 02:09:39.630
lassen, wie viel Speicher sie verbrauchen.

02:09:40.770 --> 02:09:41.550
Da hab ich jetzt auch

02:09:41.550 --> 02:09:43.570
wieder vergessen, das wusste ich. Also, du kannst

02:09:43.570 --> 02:09:45.310
in dem Pandas DataFrame sagen

02:09:45.310 --> 02:09:47.530
irgendwie meminfo oder info oder sowas

02:09:47.530 --> 02:09:49.250
und dann deep gleich true oder sowas.

02:09:49.590 --> 02:09:50.830
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.750
diesen DataFrame durch und guckt halt, wie viel

02:09:54.750 --> 02:09:57.050
Hauptspeicher brauchen da all die

02:09:57.050 --> 02:09:59.050
Dinge, die da drin sind und sagt dir halt am Ende eine Zahl.

02:09:59.350 --> 02:10:00.870
Und dann weißt du halt, okay, in diesem Ding stecken

02:10:00.870 --> 02:10:02.610
jetzt so viele Speicher drin.

02:10:03.950 --> 02:10:05.350
Dein ganzes Jupyter-Notebook,

02:10:05.590 --> 02:10:07.010
also so kannst du deine einzelnen Datenstrukturen

02:10:07.010 --> 02:10:09.210
angucken. Bei NumPy-Arrays

02:10:09.210 --> 02:10:11.090
ist es halt viel einfacher noch. Ich glaube, da gibt es

02:10:11.090 --> 02:10:13.170
auch eine Funktion, die einem sagt, welche Hauptspeicher

02:10:13.170 --> 02:10:15.070
irgendwie ein Array verwendet, aber da

02:10:15.070 --> 02:10:16.910
ist es ja einfach, du kannst dir den D-Type angucken

02:10:16.910 --> 02:10:18.930
von dem Ding und du kannst dir auch angucken

02:10:18.930 --> 02:10:20.710
mit Shape, wie viel da drin liegt und dann

02:10:20.710 --> 02:10:22.870
multiplizierst du das einfach mit, wie viel

02:10:22.870 --> 02:10:24.950
Bit hat halt irgendwie der Typ,

02:10:25.010 --> 02:10:26.850
den ich da verwende, mal Anzahl Einträge und dann weißt du,

02:10:26.950 --> 02:10:28.630
wie groß das ist, weil da ist es halt sehr einfach.

02:10:32.290 --> 02:10:33.030
Also so kann man

02:10:33.030 --> 02:10:35.090
bei einzelnen Sachen rausfinden, wie viel Hauptspeicher die verbrauchen,

02:10:35.090 --> 02:10:37.090
weil wie viel das ein Jupyter Notebook

02:10:37.090 --> 02:10:39.070
insgesamt verbraucht, siehst du halt im Top.

02:10:39.650 --> 02:10:41.130
Wie viel der Speed?

02:10:42.470 --> 02:10:42.690
Ja,

02:10:42.910 --> 02:10:43.770
da brauchst du wahrscheinlich auch,

02:10:44.010 --> 02:10:46.570
kannst natürlich auch global das

02:10:46.570 --> 02:10:48.970
bestimmen, indem du halt, also

02:10:48.970 --> 02:10:50.970
auf der Shell schreibe ich auf Time einfach davor

02:10:50.970 --> 02:10:53.250
und dann kriege ich halt dann eine Ausgabe,

02:10:53.390 --> 02:10:53.750
wie viel,

02:10:54.790 --> 02:10:56.430
wie lange es gedauert hat.

02:10:56.690 --> 02:10:58.930
Bei Jupyter-Notebook-Zellen, das gibt es auch

02:10:58.930 --> 02:11:00.990
halt irgendwie so eine Prozent-Time-Magie.

02:11:01.410 --> 02:11:03.050
Du kannst aber, wenn du jetzt einen Benchmark

02:11:03.050 --> 02:11:04.770
machen möchtest, dafür ist es natürlich nicht gut, das einmal

02:11:04.770 --> 02:11:06.250
auszuführen oder zweimal,

02:11:06.530 --> 02:11:08.850
sondern dann möchte man das halt ein paar Mal ausführen,

02:11:08.970 --> 02:11:10.750
sodass halt dann auch so Cache-Effekte und so

02:11:10.750 --> 02:11:12.910
nicht so eine Rolle spielen. Und dann, da gibt es

02:11:12.910 --> 02:11:15.050
dann halt auch Prozent-Time-It

02:11:15.050 --> 02:11:17.490
so Magie, wo das dann halt 10.000 Mal

02:11:17.490 --> 02:11:19.270
ausgeführt wird und dann wird dann halt

02:11:19.270 --> 02:11:21.390
Durchschnitt berechnet und dann ist es okay, diese Funktion

02:11:21.390 --> 02:11:23.510
dauert irgendwie üblicherweise

02:11:23.510 --> 02:11:25.290
1,7 Nanosekunden,

02:11:25.530 --> 02:11:27.530
äh, Millisekunden, Nanosekunden

02:11:27.530 --> 02:11:28.250
wäre 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.070 --> 02:11:34.170
Ja.

02:11:34.930 --> 02:11:35.290
Okay.

02:11:37.330 --> 02:11:38.850
Genau. Und ansonsten eben

02:11:38.850 --> 02:11:40.890
C-Profile kann man verwenden,

02:11:41.190 --> 02:11:43.410
wenn man jetzt noch gar keine Ahnung hat,

02:11:43.450 --> 02:11:45.310
mal nachgucken möchte und dann

02:11:45.310 --> 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.470
ist halt so ein Profile eine ganz

02:11:55.470 --> 02:11:57.390
hilfreiche Geschichte und dann, wenn man

02:11:57.390 --> 02:11:59.310
weiß, wo man Zeit verbringt, dann kann man halt mit

02:11:59.310 --> 02:12:01.750
TimeIt zum Beispiel in der Notebook-Zelle

02:12:01.750 --> 02:12:03.350
halt dann irgendwie gucken, ob man das

02:12:03.350 --> 02:12:05.370
irgendwie optimiert kriegt und dann kann man

02:12:05.370 --> 02:12:07.370
sozusagen die heißen Funktionen

02:12:08.010 --> 02:12:09.330
ein bisschen optimieren und dann

02:12:09.330 --> 02:12:12.870
sollte das schneller werden.

02:12:13.450 --> 02:12:17.690
Ja, das war die letzte Frage, glaube ich, für heute.

02:12:17.810 --> 02:12:19.090
Ich glaube, wir sind tatsächlich irgendwie durch.

02:12:19.190 --> 02:12:21.990
Wir haben viel geredet über Python selbst.

02:12:22.350 --> 02:12:23.750
Ich hoffe, das fandet ihr wieder interessant.

02:12:24.290 --> 02:12:24.450
Genau.

02:12:25.130 --> 02:12:28.410
Ja, haben wir noch irgendwie Pics oder sowas?

02:12:28.770 --> 02:12:29.150
Pic der Woche?

02:12:29.670 --> 02:12:29.850
Ja.

02:12:32.150 --> 02:12:33.110
Bis Monats.

02:12:35.370 --> 02:12:35.650
Ja.

02:12:37.210 --> 02:12:38.310
Also ich hätte da noch was.

02:12:38.630 --> 02:12:40.890
Ja, was ist dein Pic des Monats?

02:12:42.990 --> 02:12:47.150
Und zwar, ich habe mich letztens wieder damit beschäftigt,

02:12:47.630 --> 02:12:48.830
einen Rechner neu aufzusetzen

02:12:48.830 --> 02:12:53.230
und habe dann nochmal so irgendwie angeguckt,

02:12:53.350 --> 02:12:55.070
wie macht man das eigentlich,

02:12:55.190 --> 02:12:58.090
vernünftige Python-Entwicklungsumgebung aufsetzen.

02:12:58.090 --> 02:13:04.210
Dazu gab es einen Artikel von Jacob Kaplan-Moss, glaube ich,

02:13:04.890 --> 02:13:09.350
einer der Django-Gründer da,

02:13:09.810 --> 02:13:11.350
hat dazu irgendwie meine

02:13:11.350 --> 02:13:14.050
Python-Entwicklungsumgebung 2020 Edition

02:13:14.050 --> 02:13:15.690
oder so einen Artikel geschrieben, da sollte ich mal

02:13:15.690 --> 02:13:17.530
verlinken. Und da dachte ich so, ah gut,

02:13:17.690 --> 02:13:19.150
dann gucke ich doch mal, was der so macht und

02:13:19.150 --> 02:13:20.750
wie ich das so mache.

02:13:21.890 --> 02:13:23.670
Und das, worauf ich da, eine

02:13:23.670 --> 02:13:25.670
Geschichte, auf die ich da gestoßen bin, die ich vorher nicht

02:13:25.670 --> 02:13:27.590
so verwendet habe, weiß gar nicht genau, warum. Ich habe

02:13:27.590 --> 02:13:29.570
schon davon gehört, mir haben Leute davon erzählt, aber

02:13:29.570 --> 02:13:31.590
habe es irgendwie nicht benutzt, ist PyEnv.

02:13:33.350 --> 02:13:33.710
Und

02:13:33.710 --> 02:13:35.410
das war so eine der Geschichten, die ich,

02:13:35.830 --> 02:13:37.590
also genau, das wäre jetzt beim Tick, PyEnv.

02:13:38.430 --> 02:13:39.550
Und das ist eigentlich

02:13:39.550 --> 02:13:40.730
ziemlich cool, weil

02:13:40.730 --> 02:13:43.730
das ist halt ein kleines

02:13:43.730 --> 02:13:46.970
Tool, was einem

02:13:46.970 --> 02:13:49.330
dabei hilft, Python zu installieren, was

02:13:49.330 --> 02:13:51.610
überraschend schwer ist. Es sollte eigentlich nicht so schwer sein, aber es ist halt

02:13:51.610 --> 02:13:53.710
ganz schön ätzend.

02:13:53.810 --> 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:13:59.650
unterschiedlichen Arten, wie man es

02:13:59.650 --> 02:14:01.530
installiert. Für manche Projekte

02:14:01.530 --> 02:14:03.430
brauche ich halt Minikonda

02:14:03.430 --> 02:14:04.110
oder Conda

02:14:04.110 --> 02:14:07.210
und benutze auch Conda zum

02:14:07.210 --> 02:14:09.610
installieren von irgendwelchen Abhängigkeiten und so

02:14:09.610 --> 02:14:11.270
und Paketen. In anderen

02:14:11.270 --> 02:14:13.430
Webentwicklungsgeschichten wieder Virtual Envs

02:14:13.430 --> 02:14:15.750
und da auch

02:14:15.750 --> 02:14:17.630
wieder einen anderen Python-Interpreter,

02:14:17.790 --> 02:14:19.650
jetzt möglicherweise halt einfach einen, der

02:14:19.650 --> 02:14:21.310
über Homebrew gekommen ist oder

02:14:21.310 --> 02:14:23.670
den ich einfach so installiert habe oder sowas.

02:14:25.230 --> 02:14:25.910
Ja, und

02:14:25.910 --> 02:14:27.830
ja, also

02:14:27.830 --> 02:14:29.770
das war immer

02:14:29.770 --> 02:14:31.750
so ein bisschen doof und mit PyEnv ist das eigentlich

02:14:31.750 --> 02:14:33.630
relativ einfach. Da sagt man dann halt, okay,

02:14:33.770 --> 02:14:35.410
ich hätte gern, also

02:14:35.410 --> 02:14:37.570
der installiert dann halt auch, PyEnv installiert

02:14:37.570 --> 02:14:38.690
halt auch Minikonda und sowas.

02:14:39.630 --> 02:14:41.430
Und dann kann man halt sagen,

02:14:41.550 --> 02:14:43.450
okay, PyEnv install Minikonda

02:14:43.450 --> 02:14:44.790
latest und dann hat man halt die,

02:14:45.490 --> 02:14:47.130
muss man nicht mehr sich damit beschäftigen,

02:14:47.210 --> 02:14:48.230
dieses Shell-Skript,

02:14:48.610 --> 02:14:51.490
irgendwie Curl in irgendwie Shell-Skript

02:14:51.490 --> 02:14:53.390
zu pipen und dann Minikonda

02:14:53.390 --> 02:14:55.330
zu installieren, sondern das passiert alles

02:14:55.330 --> 02:14:56.530
für einen automatisch.

02:14:57.470 --> 02:14:59.470
Und man

02:14:59.470 --> 02:15:01.290
kann halt auch pro Verzeichnis dann definieren,

02:15:01.290 --> 02:15:03.150
was denn jetzt der Interpreter

02:15:03.150 --> 02:15:05.250
ist, der ausgeführt werden soll, wenn man jetzt da Python

02:15:05.250 --> 02:15:07.390
eingibt. Da gibt es dann so einen Punkt

02:15:07.390 --> 02:15:09.410
Python-Version-File und da steht

02:15:09.410 --> 02:15:11.010
das dann halt einfach drin. Und das kann halt

02:15:11.010 --> 02:15:13.430
auch ein Name

02:15:13.430 --> 02:15:15.410
von einem Virtual-Env sein. Dann ist man halt in diesem

02:15:15.410 --> 02:15:16.570
Virtual-Env.

02:15:17.110 --> 02:15:19.150
Oder es kann halt der Name sein von einem Conda-Environment.

02:15:20.090 --> 02:15:20.970
Und das ist halt

02:15:20.970 --> 02:15:23.250
sehr, sehr cool. Das heißt, ich hatte

02:15:23.250 --> 02:15:23.970
vorher sonst immer

02:15:23.970 --> 02:15:27.330
Virtual-Env-Wrapper verwendet und dann

02:15:27.330 --> 02:15:29.550
immer so Post-Activate-Skripten

02:15:29.550 --> 02:15:32.470
einmal

02:15:32.470 --> 02:15:34.530
dann halt

02:15:34.530 --> 02:15:38.410
ich überlege gerade, ob das nicht ein anderes Thema ist,

02:15:38.490 --> 02:15:38.810
aber nee,

02:15:40.870 --> 02:15:42.230
ins Verzeichnis gewechselt und dann noch so Dinge

02:15:42.230 --> 02:15:44.330
gemacht und so und das geht eigentlich

02:15:44.330 --> 02:15:46.410
quasi mittlerweile alles relativ automatisch

02:15:46.410 --> 02:15:47.470
und man muss halt auch nicht mehr

02:15:47.470 --> 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:05.150
und was man so an

02:16:05.150 --> 02:16:07.430
hilfreichen Tools da verwenden kann.

02:16:07.950 --> 02:16:09.050
Vielleicht packe ich das irgendwo auf GitHub

02:16:09.050 --> 02:16:09.950
in Gist oder so.

02:16:10.830 --> 02:16:13.310
Vielleicht haben andere Leute ja auch noch Ideen, was man da an tollen

02:16:13.310 --> 02:16:15.150
Dingen machen kann. Und vor allen Dingen, manche Sachen

02:16:15.150 --> 02:16:17.170
funktionieren auch nicht so ganz sauber. Also von

02:16:17.170 --> 02:16:19.110
irgendwie Virtual-Env nach Conda

02:16:19.110 --> 02:16:21.090
wechseln, das geht irgendwie, aber umgekehrt geht irgendwie nicht

02:16:21.090 --> 02:16:22.470
oder so. Weiß nicht genau, warum.

02:16:24.890 --> 02:16:25.090
Ja,

02:16:25.270 --> 02:16:27.130
und vielleicht wäre das mal eine sinnvolle

02:16:27.130 --> 02:16:29.010
Geschichte, das mal zusammenzutragen. Was muss man eigentlich

02:16:29.010 --> 02:16:31.090
machen, um halt eine ordentliche Partner-Entwicklungsumgebung

02:16:31.090 --> 02:16:32.570
irgendwie aufzusetzen?

02:16:32.610 --> 02:16:34.750
Ja, das klingt auf jeden Fall nach einer guten Sache.

02:16:35.430 --> 02:16:35.630
Genau.

02:16:36.850 --> 02:16:38.650
Ja, und genau,

02:16:38.730 --> 02:16:41.070
Pines fand ich jetzt sehr, sehr

02:16:41.070 --> 02:16:42.690
überzeugend eigentlich und

02:16:42.690 --> 02:16:44.130
bin ich eigentlich

02:16:44.130 --> 02:16:46.970
dachte ich mir, warum finde 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.930
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.990
Pick der Woche. Ich nehme diesmal Turtle.

02:16:55.450 --> 02:16:56.810
Diese kleine Bibliothek, mit der man

02:16:56.810 --> 02:16:58.690
kleine Sachen zeichnen kann auf einer Kenner.

02:16:58.690 --> 02:17:00.450
Ach, Turtle-Grafik, ja. Ja, weil da kann man tatsächlich

02:17:00.450 --> 02:17:02.610
sehr 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.550
berechnen lassen, Funktionen, und der

02:17:06.550 --> 02:17:08.750
zeichnet dann ganz tolle, witzige

02:17:08.750 --> 02:17:10.730
Bilder, mit denen man Computerkunst macht.

02:17:11.330 --> 02:17:12.730
Also unabhängig davon, dass man

02:17:12.730 --> 02:17:14.830
jetzt 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.750
Das fand ich sehr witzig, deswegen wollte ich das nochmal

02:17:18.750 --> 02:17:20.690
picken. Ja, cool,

02:17:20.790 --> 02:17:22.370
cool, cool. Ja,

02:17:22.490 --> 02:17:24.650
vielen Dank fürs Zuhören. Egal wann

02:17:24.650 --> 02:17:26.230
ihr hört, montags, mittags,

02:17:26.790 --> 02:17:28.650
abends, nachts, bleibt uns gewogen,

02:17:28.730 --> 02:17:30.610
Habt viel Spaß und wir hören uns bald wieder.

02:17:30.770 --> 02:17:31.790
Ja, bis zum nächsten Mal.

02:17:31.930 --> 02:17:32.250
Tschüss.

02:17:32.330 --> 02:17:32.570
Tschüss.

02:17:58.730 --> 02:18:28.710
Untertitelung des ZDF, 2020

02:18:28.730 --> 02:18:37.250
Auf Takt

02:18:37.250 --> 02:18:41.270
Im Takt

02:18:41.270 --> 02:18:44.790
Im Für-Takt

02:18:44.790 --> 02:18:47.890
Soll es klingen

02:18:47.890 --> 02:18:53.550
Drei Klangs-Dimensionen

02:18:53.550 --> 02:18:55.170
So taktvoll

02:18:55.170 --> 02:19:13.310
Lichtspiel, Impressionen, Gefahr, Farbton, Halbton und Synchron

02:19:13.310 --> 02:19:24.070
Dazu schwingen, Dreiklangs, Dimensionen, Kontaktvoll

02:19:24.070 --> 02:19:31.250
Lichtspiel, Impressionen, so fassbar

02:19:44.250 --> 02:19:56.770
Wohlklang, Illusionen, die um uns herum tanzen.

02:19:59.690 --> 02:20:03.810
Dreiklangs, Dimensionen, so taktvoll.

02:20:06.510 --> 02:20:11.030
Lichtspiel, Impressionen, so farbvoll.

02:20:14.090 --> 02:20:25.770
Klänge für Millionen, überwinden die Distanzen.

02:20:25.770 --> 02:20:39.950
Drei Klangsdimensionen, so taktvoll, Lichtspiel, Impressionen, so fachvoll.

02:20:44.090 --> 02:21:14.070
Bis zum nächsten Mal.

02:21:14.090 --> 02:21:44.070
Untertitelung des ZDF, 2020

02:21:44.090 --> 02:22:07.070
Ausklang

02:22:07.070 --> 02:22:10.350
Abgang

02:22:10.350 --> 02:22:13.590
Sequenz

02:22:13.590 --> 02:22:31.990
Drei Klangsdimensionen, so taktvoll Lichtspiel, Impressionen, so farbvoll

02:22:31.990 --> 02:22:39.190
Drei Klangsdimensionen, so taktvoll

02:22:39.190 --> 02:22:46.290
Lichtspiel, Impressionen, so farbvoll

02:22:46.290 --> 02:22:53.530
Dreiklangs, Dimensionen, so taktvoll

02:22:53.530 --> 02:23:00.750
Lichtspiel, Impressionen, so farbvoll

02:23:03.750 --> 02:23:07.950
Dreiklangs, Dimensionen, so taktvoll

02:23:07.950 --> 02:23:15.230
Lichtspiel, Impressionen, so farbvoll

02:23:15.230 --> 02:23:22.410
Dreiklangs, Dimensionen, so taktvoll

02:23:22.410 --> 02:23:29.630
Lichtspiel, Impressionen, so farbvoll

02:23:33.310 --> 02:23:36.830
Dreiklangs, Dimensionen, so taktvoll

02:23:36.830 --> 02:23:58.870
Untertitelung des ZDF für funk, 2017