Python richtig lernen, wie?

[Fimbur]

Hallo,
gerne möchte ich Python richtig lernen. Mir ist aber aufgefallen, vieles was man dazu im Internet findet ist leider veraltet.
Ich möchte auch nicht einfach Code abschreiben, sondern verstehen warum der Code funktioniert.
Leider bin ich nicht der Typ, der gut aus Büchern lernen kann. Nach online Kursen habe ich mich auch schon umgesehen, leider sind dieser oftmals sehr teuer.
Möchte das lernen von Python nur als Hobby betreiben.
Gibt es eine gute Anlaufstelle, die aktuell ist und vielleicht sogar auf Deutsch, die empfehlenswert ist für Anfänger?
Bin dankbar für jede Art von Hilfe.

[noisefloor]

Hallo,

idealerweise programmierst du ein Projekt / Programm, an dem du Spaß hast und was für dich nützlich ist. Das ist am effektivsten und hat für die die beste Motivation.

Zum Lernen eignet sich sehr gut das offizielle Python-Tutorial auf python.org. Und natürlich Code hier posten, Kritik abholen und besser machen

Gruß, noisefloor

[ThomasL]

Hi,
ich weiss jetzt nicht wo du gesucht hast und was du gefunden hast. Ich habe mal auf Youtube gesucht und diese Tutorials auf Deutsch gefunden.
Von den ersten drei Youtubern habe ich mir selbst viele Videos über die Jahre angesehen.

https://www.youtube.com/watch?v=DiidEp6 ... 4oBgp3E9Zs

https://www.youtube.com/watch?v=jqNH0j3 ... rAZxoHcN4o

https://www.youtube.com/watch?v=C8R5zt7 ... o1kJoOAMC6_

Diese beiden habe ich gerade erst entdeckt und sind neu in der Szene, kann ich daher nicht beurteilen.

https://www.youtube.com/watch?v=oxXAb8I ... AQ74D0TqZB

https://www.youtube.com/watch?v=VKjUVTO ... SnDzO9flzH

[Buchfink]

Hallo @ThomasL
lieben Dank für die Links! (Ich bin zwar nicht der TE, ich hoffe dass es trotzdem ok ist, wenn ich hier reinschreibe)
Bin grad dran die Videos durchzu"hören" und da sind einige Dinge dabei, die ich aktuell direkt gebrauchen kann.

Und danke auch für die Einschätzung zur Qualität.

Als Python-Anfänger bin ich da leider oft ratlos. Bei den Udemy-Tutorials, die ich mir angesehen habe, war die Qualität (soweit ich das überhaupt beurteilen kann) recht unterschiedlich. Oft ging es nicht sonderlich in die Tiefe und ich hatte aufgrund von Widersprüchen immer wieder das Gefühl, der Dozent weiß selbst nicht so richtig, warum er grad dies oder jenes tut. Teilweise wurden da auch "nur" die Bücher des Dozenten beworben: So nach dem Motto "Wenn du mehr wissen willst, kaufe das Buch". Bei Cousera muss ich gestehen, hatte ich immer das Gefühl, ein riesiges Wollknäul vor mir zu haben und irgendwie nicht "den Anfang zu finden, um das Knäul aufzuwickeln".

Ich hatte auch initial mit einem selbst erdachten Projekt angefangen, hab dann aber beim Implementieren gemerkt, dass ich die Grundlagen nicht fundiert genug kenne, um gute Entscheidungen zu treffen. Ich hatte auch zwischenzeitlich ein Buch von Sebastian Raschke gekauft, das hab ich aber nach 13% in die Ecke gelegt (heute weiß ich auch warum).
Hab's neulich nochmal zur Hand genommen. Vieles verstehe ich nun besser und muss sagen, dass dort oft einfach relevante Erklärungen "wozu dient das denn?" ausgespart wurden.

Die offiziellen Primärquellen zu Python sind wiederum oft dahingehend schwierig, dass man als Anfänger da oft "reinguckt wie ein Schwein ins Uhrwerk". Diese Dokumente haben den Anspruch exakt und korrekt zu sein. Damit befindet man sich aber inmitten eines Dschungels an Details und weiß oft gar nicht, wo man zuerst hinschauen soll.

Und im Moment hilft mir dieses Forum am allermeisten.

[narpfel]

https://www.youtube.com/watch?v=DiidEp6 ... 4oBgp3E9Zs

https://www.youtube.com/watch?v=jqNH0j3 ... rAZxoHcN4o

https://www.youtube.com/watch?v=C8R5zt7 ... o1kJoOAMC6_

[...]

https://www.youtube.com/watch?v=oxXAb8I ... AQ74D0TqZB

https://www.youtube.com/watch?v=VKjUVTO ... SnDzO9flzH

Ich habe da mal ein bisschen durchgeskippt:
Kandidat 1 fällt durch mit dem klassischen `socket.send(b"foo")`

Kandidat 2 macht den gleichen Fehler, empfiehlt aber zusätzlich noch, `sys.path` („like a Boss“) anzupassen.

Kandidat 3 benutzt Qt, um auf eine SQLite-Datenbank zuzugreifen, aber generiert anscheinend Code aus .ui-Dateien?

Kandidat 5 ist Fan von Bobby Tables. Ganz übel.

Und Kandidat 4 sagt anscheinend nichts über Sockets oder Datenbanken, da müsste man also genauer hingucken.

Von daher gibt es für Nummer 1, 2 und 5 ganz klar ein -1 von mir. Das sind Fehler, die man IMHO nicht machen darf, wenn man Leuten etwas beibringen will.

[Buchfink]

ich hatte mich vorhin bei "The Morpheus Tutorials" auch ein bisschen durchgeklickt und bin dann hier gelandet https://www.youtube.com/channel/UCLGY6_ ... dmmjR1J_7w

Ca. bei Minute 8 kam dann auch eine etwas merkwürdige Aussage zu c#. Sinngemäß: "C# ist eigentlich mehr wie Java als wie C" wirkt irgendwie seltsam, wenn man weiß, dass C# von Anders Hejlsberg kommt. Der hat auch Delphi erfunden. Und da kommt der ganze "RAD"-Krempel her. (RAD ist das Zeug, was Unmengen an Entwicklern zu Tage gebracht hat, die sich Oberflächen und DB-Komponenten zusammenklicken und dann die ganze Businesslogik in den Event-Handlern hinterlegen)

Aber ich möchte das jetzt keinesfalls überbewerten, denn ich rechne das eher zu Thorngates Postulat der angemessenen Komplexität. (Entweder ist es didaktisch einfach und ein bisschen falsch. Oder es ist didaktisch schwer und dafür richtig)


@narpfel.
ich bin ein wenig irritiert.
Was genau meinst Du mit

Von daher gibt es für Nummer 1, 2 und 5 ganz klar ein -1 von mir.

-1 --> false?

[narpfel]

@Buchfink: -1 == keine Empfehlung. Wobei das noch freundlich ist, das sind ja alles keine Bücher, die man wegwerfen könnte.

[Buchfink]

@narpfel
danke - ich hab mich nur gefragt, auf welcher Skala die Bewertung ist
Ich hatte überlegt, ob es vielleicht ein Python-Scherz sein könnte.

Im Moment befürchte ich, dass man leider fast in jedem Tutorial irgendwas finden wird, was nicht "rund" ist. Ich denke, wenn man immer schön kritisch bleibt, dann kann man Widersprüche/Fehler/Lücken anderweitig kompensieren. Hoffe ich jedenfalls.

Ein Entwickler muss ja ohnehin eine gewisse Fähigkeit haben, solche Dinge zu erkennen. Es kann ja auch sein, dass man mal eine Spezifikation lesen muss, in der sich Widersprüche/Fehler/Lücken tummeln. Da muss man ja auch jedes Wort auf die Goldwaage legen und "abwiegen".
Also immer schön kritisch bleiben

Aber ich verstehe auch, dass es problematisch ist, wenn immer wieder Fehlinformationen ausgeräumt werden müssen, weil sich irgendwelches gefährliche Halbwissen hartnäckig hält.

LG

[sparrow]

@Buchfink: Was findest du denn an der Aussage seltsam, dass C# mehr Java als C ist? Das ist ja nicht abhängig davon, wer Chefentwickler einer Sprache ist.

[narpfel]

@Buchfink: Das ist nicht ein wenig „unrund“, das ist „Willkommen zur ersten Fahrstunde. Die Rückspiegel brauchst du nicht, du fährst ja vorwärts.“ Und ich habe auch nicht lange suchen müssen, bis ich irgendeine Kleinigkeit finde, sondern das war jeweils das erste Video, das ich angeklickt habe.

[Buchfink]

@sparrow
ich habe da primär an den Müll mit den RAD-Geschichten gedacht. "Klicke die Software zusammen". ^^
Das kam bei Borland Delphi auf und ist dann auch bei Microsoft irgendwann aufgetaucht.

Natürlich stecken in c# auch Konzepte aus Java drin.

[sparrow]

@Buchfink: Ok, das erschließt sich mir nicht. RAD empfinde ich auch nicht als Müll. Das kann - je nach Anwendungsfall - durchaus Sinn machen.
Aber ansonsten beschreibt "C# ist eher Java als C" durchaus korrekt und beschreibt auch meinen ersten (syntaktische) Eindruck, als ich damals C# das erste Mal gesehen habe. Merkwürdig finde ich die Aussage nicht.

[__blackjack__]

@Buchfink: -1 ist ja nicht gleich `False`. 0 wäre das. Es ist auch nicht gleich `True`. Aber im boole'schen Kontext wird es dann schon wie `True` behandelt, denn da ist nur die 0 `False`.

Code: Alles auswählen

In [226]: -1 == False                                                           
Out[226]: False

In [227]: 0 == False                                                            
Out[227]: True

In [228]: -1 == True                                                            
Out[228]: False

In [229]: 1 == True                                                             
Out[229]: True

In [230]: bool(-1)                                                              
Out[230]: True

In [231]: bool(0)                                                               
Out[231]: False

In [232]: bool(1)                                                               
Out[232]: True

Die -1 ist in vielen klassischen BASIC-Dialekten ”wahr” weil es dort streng genommen keine logischen Verknüpfungen gibt sondern nur die bitweisen NOT, AND, OR. Und wegen NOT geht halt 0 und 1 nicht wirklich weil NOT 0 = -1 gilt.

Bezüglich C#/C/Java: C# und Java haben gegenüber C auch gemein, dass es Hochsprachen sind, dass die grundlegenden Zahldatentypen eine feste Bitgrösse haben, dass Speicher automatisch verwaltet wird, dass es Ausnahmen gibt, dass es Klassen gibt, und dass die Zielplattform des Compilers in der Regel nur die eine — die für die Sprache spezifizierte virtuelle Maschine ist, statt allgemein eine abstrakte Maschine, die es so erst einmal nur auf dem Papier/im Standard gibt, die in der Realität dann aber auf einen ganzen Zoo von teilweise sehr unterschiedlicher Hardware direkt abgebildet wird.

Ich denke beim GUIs zusammenklicken war es anders herum: Visual Basic 1 (1991) bis 3 (1993) sind älter als Delphi 1 (1995). Microsoft ist Schuld!

[Buchfink]

@narpfel

Das ist nicht ein wenig „unrund“, das ist „Willkommen zur ersten Fahrstunde. Die Rückspiegel brauchst du nicht, du fährst ja vorwärts.“

hm. Hier wäre mal interessant zu wissen, was konkret falsch ist.
Bzw. wenn so viele Falsch-Informationen kursieren, wäre die Frage, ob das ein lösbares Problem ist? (Ehrlichgesagt: ich weiß es nicht. Ich habe ja auch schon gezielt danach gesucht, ob es vielleicht eine Zusammenstellung der "falschen Fuffziger" gibt. Etwas das in die Richtung geht, wäre das hier: https://nbviewer.org/github/rasbt/pytho ... vate_class. Aber auch das ist wohl mit Vorsicht zu genießen.)

Vielleicht ein paar Worte zu _meiner_ Vorgehensweise, wenn ich mir solche Tutorials anschaue:
Die meisten Videos darin gehen so 5 - 15 Minuten. Wenn ich mir ein einziges Video anschaue, verbringe ich meist etliche Stunden damit, mir selbst zu dem Thema Fragen zu stellen und z.B. durch Ausprobieren, Doku lesen oder Google-Recherchen zu beantworten. Da ich das nur in meiner Freizeit mache, dauert das leider ziemlich lange, bis ich so ein komplettes Tutorial geschafft habe. (Manche breche ich auch ab, wenn darin zu viele Ungereimtheiten auftauchen oder wenn es didaktisch nicht hilfreich ist. Ich sehe das aber als Teil des Lernprozesses. Man muss einfach kucken, was für einen selbst funktioniert)
Wenn ich dann immer noch nicht weiterkomme, frage ich hier nach, denn hier sind ja jede Menge Experten anzutreffen.

Natürlich ist das Problem von Falschinformationen, dass sie sich regelrecht "einschleifen" und man dann mit diesen Dingen im Alltag zu kämpfen hat. (Da schreibe ich gleich nochmal was separat dazu)

[ThomasL]

..... Und ich habe auch nicht lange suchen müssen, bis ich irgendeine Kleinigkeit finde, sondern das war jeweils das erste Video, das ich angeklickt habe.

Wobei du echt ganz zufällig das Video "Python Tutorial #52 - Sockets" von Morpheus ausgewählt hast, na klar.

[Buchfink]

@sparrow

Ok, das erschließt sich mir nicht. RAD empfinde ich auch nicht als Müll. Das kann - je nach Anwendungsfall - durchaus Sinn machen.

Hier habe ich meine Worte vielleicht etwas zu hart gewählt.

Aber ich möchte es auch begründen.
1)
In Delphi funktioniert die RAD-Thematik auf den ersten Blick zwar recht gut. Wenn man jedoch komplexere Oberflächen bauen möchte, ist man z.B. mit Vererbung ganz schlecht beraten und auch Aggregation funktioniert eher so lala. Man muss sich vorstellen, dass Delphi dazu Kommentare erzeugt, diese auswertet und per Magie kann man sich dann Oberfächen aus anderen Oberflächen zusammenzimmern.
Wenn ihr jetzt "OMG" denkt, denkt ihr genau richtig
Nach meinem Wissensstand funktioniert das in C# deutlich besser.

2) Ich sehe die RAD-Thematik als weitestgehend gescheitert an. Denn das Versprechen war ja, dass man damit "rapid" Software entwickeln kann. Aber die Wahrheit ist, dass das Erstellen von Oberflächen oft nur einen Bruchteil der eigentlichen Arbeit ausmacht und ich kenne kein einziges Projekt, dass wg. RAD schneller fertig geworden wäre. Man bekommt ggf. ein paar Stunden früher einen Prototypen. Und die eigentliche Arbeit steckt ja oft im Klären von Anforderungen bzw. in irgendwelchen Details, die zu beachten sind.

3) Die RAD-Technik hat zumindest in Delphi dazu geführt, dass die "Hemmschwelle" zum Programmieren drastisch herabgesenkt wurde. Das wiederum hat dazu geführt, dass sehr viele Leute "Oberflächen und Datenbankanbindungen" zusammengeklickt haben und sich anschließend auf Entwicklerstellen beworben haben. Hier muss ich jetzt auf @narpfels Beitrag kommen. Dadurch hat sich leider sehr viel Falschwissen verteilt, dem nicht mehr Herr zu werden ist. (Ich erinnere mich an etliche ehemalige Kollegen, die die Probezeit nicht überstanden haben, da sie das komplette Backend in die Event-Handler gehäkelt haben. Hinzu kam, dass es in diesem Code vor Speicherlecks nur so gewimmelt hat. Solcher Code ist wirklich gefährlich und kann Regressforderungen etc. nach sich ziehen.)

Aber ansonsten beschreibt "C# ist eher Java als C" durchaus korrekt und beschreibt auch meinen ersten (syntaktische) Eindruck, als ich damals C# das erste Mal gesehen habe. Merkwürdig finde ich die Aussage nicht.

Ich bin von C# auf Delphi migriert und muss sagen, dass vieles extrem ähnlich ist. Man fühlt sich in vielen Dingen "sofort zu Hause". Und nach meinem Empfinden auch sehr viel ähnlicher als zu Java. Allerdings ist das eher Bauchgefühl und die Vokabel "seltsam" ist auch in diesem Sinne zu lesen
Mir kam die Aussage eher so vor wie "Eine Blume ist mehr wie ein Fisch": Ja beides sind irgendwie Lebewesen. Aber sonst....hm... (und genau da kommt das seltsame Gefühl ins Spiel)
Aber bei "Gefühlen" ist es ja ohnehin schwer zu argumentieren. Daher bitte einfach wegsortieren.

[Buchfink]

@__blackjack__

-1 ist ja nicht gleich `False`. 0 wäre das. Es ist auch nicht gleich `True`. Aber im boole'schen Kontext wird es dann schon wie `True` behandelt, denn da ist nur die 0 `False`.

Du hast in diesem Punkt völlig Recht. Und in diesem Kontext (viewtopic.php?f=1&t=53114&p=394240#p394240) hatte ich das auch schon "herausgefunden". Dies sei zu meiner Ehrenrettung gesagt
In MS-Access ist -1 aber tatsächlich false, vermutlich ist da in meinen Kopf eine weitere Assoziation (weil ich hin und wieder MS-Access-DBs auswerten muss). Jedenfalls erschien mir die "-1" im gegebenen Kontext irgendwie uneindeutig, da ich mich gefragt habe, auf welcher Skala sie einzusortieren ist.
Und meine Assozionskette war dann einfach "von hinten zu lesen".
Der Kommentar hinter der "-1" war ja so formuliert, dass die Tutorials nicht zu empfehlen sind und ich hab nicht gecheckt, wie das mit -1 in Verbindung steht. Mein Hirn hat wohl folgendes ausgerechnet:
"nicht zu empfehlen" --> (weil) falsch --> false --> -1 --> Widerspruch!?

Ich wollte nur sicher gehen, dass ich @narpfels Beitrag wirklich richtig interpretiere.

Hätte da "5-" gestanden, hätte ich wohl die Assoziation mit Schulnoten gehabt, dann wäre es zumindest "gefühlt" wieder eindeutig gewesen. Aber sei's drum. Die Message von @narpfel ist ja angekommen

Ich denke beim GUIs zusammenklicken war es anders herum: Visual Basic 1 (1991) bis 3 (1993) sind älter als Delphi 1 (1995). Microsoft ist Schuld!

Die Delphi-Gemeinde macht den Abgang von Hejlsberg zu Microsoft dafür verantwortlich, dass es bei Borland, CodeGear und wie sie alle hießen anschließend kaum noch echte Innovation gab. Die RAD-Thematik war wohl auch ein Grund dafür, dass Delphi eine Zeitlang relativ erfolgreich war und dann plötzlich eben nicht mehr. (Es gab noch andere Gründe, die damals eine Rolle spielten auf Delphi zu setzen. Aber ich glaube, das interessiert hier keinen )
Ich bin mir nicht sicher, wie das in Visual Basic 1991 tatsächlich ausgesehen hat und was Borland daraus gemacht hat.
Ich vermute, dass es so in die Richtung geht, wie man sich auch in MS-Access Oberflächen zusammenklicken kann (vielleicht meinst Du das auch)

LG

[__blackjack__]

@Buchfink: Ich denke Delphi war wegen dem Pascal-Erbe erfolgreich, relativ zu Visual Basic beispielsweise, und weil Pascal nativ kompiliert war und Visual Basic in der Regel ”P-Code“, der von der jeweiligen VBRUN*.DLL die man ja immer brauchte, dann interpretiert wurde.

In Visual Basic hat man sich GUIs zusammengeklickt und dann in den Event-Handlern die ganze Logik hinterlegt. Und ich meine die eigenständige Programmiersprache, nicht VBA, das in andere Microsoft-Produkte eingebettet ist.

[Buchfink]

@__blackjack__

In Visual Basic hat man sich GUIs zusammengeklickt und dann in den Event-Handlern die ganze Logik hinterlegt

OMG

Und ja: die Performance des Compilers hatte bei der Entscheidungsfindung wohl eine Rolle gespielt.
Allerdings fiel diese Entscheidung "vor meiner Zeit".
Die historische Betrachtung ist durchaus interessant. Am Montag frage ich mal nach. Das interessiert mich jetzt

LG

[narpfel]

Wobei du echt ganz zufällig das Video "Python Tutorial #52 - Sockets" von Morpheus ausgewählt hast, na klar.

Natürlich nicht. Sockets und SQL sind halt (leider) anscheinend ein guter Lackmustest.

Gerade deswegen ist das ja so gruselig. Das sind bekannte Fehler, nicht irgendwelche obskuren Details, von denen man noch nie was gehört hat.