@Tron0070: Wie
kbr zu dem Vorgehen mit dem verkleinern des Codes um den Fehler einzugrenzen bereits schrieb ist das im Grunde die falsche Richtung. Denn das macht viel mehr Arbeit einem grossen Quelltext zu verfassen und *dann* die Fehler zu suchen, als immer kleine, in sich geschlossene Funktionen zu schreiben, und die zu testen, und so einen grossen Quelltext ohne Fehler zu schreiben. Das gelingt natürlich nicht immer, und manchmal muss man dann auch in einer grösseren Quelltextbasis Fehler finden. Aber auch dann ist es von Vorteil wenn der aus einzeln testbaren Funktionen besteht, weil man dann den Fehler leichter eingrenzen kann.
Das kann auch zu einer Motivationsfrage werden. Mal angenommen man macht bei beiden Vorgehensweisen die gleiche Anzahl von Fehlern. Wenn man das Programm Stück für Stück, Funktion für Funktion entwickelt und immer testet, dann trifft man während der Entwicklung auf einen Fehler nach dem anderen, hat aber zwischendurch immer wieder ein (hoffentlich) fehlerfreies Programm, von dem man weiss, das es soweit läuft, weil man ja immer testet. Man sieht einen Fortschritt. Wenn man aber erst ganz viel Code schreibt, und das Programm im Grunde fertig ist, weil für alles was das Programm machen soll der Code schon da ist, und dann erst testet und Fehler sucht, dann hat man eine ganze Weile das Gefühl man tritt auf der Stelle, weil man schon zu 99% am Ziel ist, aber die ganze Zeit für *alle* Fehler in dem letzten 1% drauf geht, man aber nicht das Gefühl hat, das man voran kommt, weil immer wenn man einen Fehler gefixt hat und das Programm laufen lässt, der nächste Fehler sichtbar wird. Das kann sehr demotivierend wirken. Und man ist auch eher geneigt unsaubere Hacks zu schreiben und Fehler nur oberflächlich zu reparieren, nur um endlich das ganze zum laufen zu bringen.
Es kann auch zu unnötiger Arbeit führen, nämlich dann, wenn man alles ”fertig” hat und dann auf einen Fehler stösst, der einem zeigt, dass man etwas grundsätzlich nicht so lösen kann, wie man sich das gedacht hat. Dann muss man manchmal grosse Teile des Quelltextes ändern oder gar komplett neu schreiben. Wenn man während der Entwicklung schon die Fehler in den kleinen Teillösungen sucht und behebt, stösst man auf so ein Problem bevor man Code schreiben kann, der sich auf etwas verlässt, was so nicht funktioniert.
Zum Code: Den aufzuräumen kommt auf jedem Fall einem neu schreiben des gesamten Quelltextes gleich. Da macht es fast keinen Sinn sich über die ”Klassen” zu unterhalten. Da weiss ich fast nicht wo ich anfangen soll. Das sind nicht wirklich Klassen. Klassendefinitionen gehören nicht in eine verschachtelte Ebene, das macht nur selten einen Sinn und wenn dann in einer einfachen Verzweigung aber ganz sicher nicht so tief und in einer Schleife.
Dann haben Deine Klassen gar keine Methoden sondern Funktionen die Du über das Klassenobjekt aufrufst. In seltenen Fällen kann das mal Sinn machen eine Funktion auf einer Klasse zu haben, die weder ein Exemplar dieser Klasse noch die Klasse selbst benötigt, aber trotzdem so eng mit der Klasse gekoppelt ist, dass man sie nicht als eigenständige Funktion schreibt, sondern als `staticmethod()`.
Datenattribute auf Klassen sind in aller Regel Konstanten. Man führt im Klassenkörper keinen Code aus der Webseiten abfragt oder ähnlich drastische Seiteneffekte und Anforderungen an die Umgebung hat.
Und diese falschen ”Klassen” sind Teil von einem riesigen ca. 190 Zeilen langen Codemonster, mit Unmengen an globalen Variablen, das kein Mensch wirklich verstehen kann. Du läufst mit der Entwicklung in die völlig falsche Richtung, triffst bereits auf Probleme die dadurch entstehen, willst aber aber weiter in diese Richtung laufen und fragst uns wie man denn richtig in die falsche Richtung läuft. Das macht keinen Sinn. Wie gesagt, ist das jetzt bereits nichts mehr was man mit kleinen Reparaturen geradebiegen kann.
Fang das am besten noch mal neu an, mit Funktionen. Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Funktionen (und Methoden) bekommen alles was sie ausser Konstanten benötigen als Argument(e) übergeben. Ergebnisse werden mit ``return`` an den Aufrufer zurückgegeben. Eine Funktion löst eine in sich geschlossene Aufgabe mit wenigen Zeilen Code, so dass man jede Funktion für sich leicht lesen und verstehen kann.
Erster sinnvoller Einsatz für Klassen könnte das sein was Du schon so ein bisschen versucht hast: Datenklassen. Also erst einmal nur verschiedene Werte die sinnvoll zusammengehören zu einem Objekt zusammengefasst. Ohne Methoden. Ob man dann Code hat der sinnvoll als Methode zu solchen Daten gehört kann man dann noch sehen.
