Trivialste Frage (Loop, Unterteilung)

[Quicktrader]

Hallo,

bin ein Newbie und mir fehlt folgender Ansatz..nehmt bitte an, mein Programm hat schon ein paar Seiten und sieht in etwa wie folgt aus (Beispiel):

#LISTEN
Alphabet = ['A', 'B', 'C',...]
Vokale = ['A', 'E', 'I',...]
Namen = ['Hans', 'Jürgen',....]


#FUNKTIONEN
def Struktur1
......Struktur1 = x+y+z+x+z+y
......return Struktur1

def Struktur2
......Struktur2 = x+y+x+x+b+c+z+y......
return Struktur2

def Struktur3
......Struktur3 = z+y+k+l+b
......return Struktur3


#MAIN
For x,y,z...:
......if Struktur 1 in Namen:
............b,c in Alphabet..
............if Struktur2 in Namen:
..................k,l in Vokale
..................if Struktur 3 in Namen:
........................print("Hurra, Erfolg!")
..................else:
........................print("Leider nein")
............else:
..................print("Leider nein")
......else:
............print("Leider nein")


Mein Problem besteht in einer einfachsten (!) Aufteilung des MAIN Programms. Bisweilen arbeite ich mit ein paar Listen, Variablen, Funktionen - auch innerhalb des Hauptprogramms - in dem Sinn, dass zunächst die Variablen xyz und die erste Struktur erstellt/geprüft werden kann. Falls ein Treffer, kommen andere Variablen hinzu, z.B. b, g oder eben dann, eine Stufe weiter, auch k, l. Die letzten vier Variablen werden in der ersten Stufe jedoch noch nicht benötigt.

Durch die Verschachtelte Struktur der ganzen Listen, Variablen und Funktionen verzettelt sich das Programm jedoch leider ungemein (und rattert jeden einzelnen Buchstaben durch). Viel lieber wäre mir eine Struktur wie folgt:

#MAIN
Teilprogramm 1 - Gestalte Struktur 1
for x,y,z
Strukur1...

Teilprogramm 2 - Gestalte Struktur 2
x,y,z aus Struktur 1
for b,c
Struktur2

Teilprogramm 3 - Gestalte Struktur 3
x,y,z aus Struktur 1
b,c aus Struktur 2
for k,l
Struktur 3

#MAINMAIN
If Struktur1 in Namen and Struktur 2 in Namen and Struktur 3 in Namen:
......print("Hurra Erfolg")
Else:
......print("Leider nein")


Hinweise, welche darauf abzielen aus jedem Teilprogramm eine Funktion zu machen, funktionieren eher nicht. Vor allem, da in jedem Teilprogramm verschiedene Variablen, Funktionen, While-Loops und IF-Klauseln gesetzt sind. Am 'liebsten' wäre mir, wenn sich um das erste Teilprogramm eine Art KLAMMER schließen ließe, so dass ich dieses eindeutig in sich abgrenzen kann und in MAINMAIN zunächst auf das Erstergebnis (!) von Teilprogramm 1 und dann bereits auf das nächste Teilprogramm zusteuern kann. Oder die Teilprogramme gar als Multiprocessing oder dergleichen parallel synchronisiert laufen lassen kann. Leider bin ich mit keinem der Ansätze (def, async, thread, class usw.) bisher weitergekommen, diese zig-fach verschachtelte IF-Klausulierung einfacher zu strukturieren.

Falls jemand einen Tipp hat, einen kompletten Programmierbaustein an sich abzugrenzen, dennoch Resultate daraus heranziehen zu können (Vererbung), wäre mir sehr geholfen - thx.

Quicktrader

[sparrow]

Dein Vorgehen klingt falsch, auch wenn du die Antwort in deiner Frage explizit nicht hören möchtest.

Teilaufgaben werden in Funktionen gekabselt. Funktionen bekommen alles, was sie benötigen, als Parameter und geben ein Ergebnis zurück.
Auf Modulebene (also nicht eingerückt) stehen nur die Importe, die Definitionen von Funktionen und Klassen und die Import-Weiche zum Starten der ersten Funktion.
Variablen gehören dort nicht hin. Nur Konstanten (die man daran erkennt, dass sie KOMPLETT_GROSS geschrieben sind. Konstanten heißen Konstanten, weil man sie nie ändert. Dazu gehört auch, dass - wenn es sich um Listen handelt - aus denen nur gelesen aber niemals etwas am Inhalt geändert wird.
Muss ein Zustand behalten werden, macht ggf. der Einsatz von Klassen Sinn.

Wenn man das befolgt ergibt sich die Struktur quasi von alleine.

Statt ausgedachten Pseudo-Code solltest du deinen Versuch zeigen. Es wird dann sicherlich Kommentare zur Verbesserung geben.
Zum Posten von Code gibt es hier im Forum die Code Tags. Die werde eingefügt wenn du den </> im vollständigen Editor drückst.

[__blackjack__]

@Quicktrader: Ich möchte mich sparrow anschliessen. Funktionen sind das sprachliche Mittel um Teilaufgaben zu kapseln oder wie Du das formulierst „eine Art Klammer“ um ein Teilprogramm „eindeutig in sich abgrenzen“ zu können. Dafür sind die da um eine Teilaufgabe mit ihren lokalen Variablen nach aussen abzugrenzen, eine definierte Schnittstelle nach aussen über die Argumente die übergeben werden und den Rückgabewert zu bieten. Das macht sie dann auch einzeln testbar, was die Fehlersuche erleichtert.

Was an dem Pseudocode nicht gut ist, sind die Namen. Funktionen (und Methoden) werden üblicherweise nach der Tätigkeit benannt die sie durchführen. Damit weiss der Leser was die Funktion tut, und man kann Funktionen dann auch leicht von eher passiven Werten unterscheiden. „Struktur 1“ ist keine Tätigkeit, und damit kein passender Name für eine Funktion.

Bei der gezeigten Hauptfunktion, die wie sparrow schon erwähnte tatsächlich in einer Funktion stecken sollte, würde ich versuchen die einzelnen Prüfkriterien so in Funktionen zu verpacken, dass man darüber eine Schleife schreiben kann, die nacheinander die Bedingungen prüft, und das ``else`` nur einmal schreiben, nämlich für den Fall, dass nicht alle der Bedingungen zutraf.

[noisefloor]

Hallo,

was hast du denn genau vor? Durch den Pseudocode ist das alles eben nicht trivial, weil daraus so Null Komma Null hervorgeht, wie das reale Problem hast. Es macht in der Regel auch - gerade als "Newbie", aber auch als fortgeschrittener - ganz selten Sinn zu versuchen, das Problem abstrakt darzustellen, weil das einfach viel zu einfach schief gehen kann und man damit entweder (noch mehr) Fehler einbaut oder das eigentliche Problem verschleiert.

Es hört sich aber in der Tat so an, als das es eine bessere Lösung geben könnte, zumal Python beim Iterieren ziemlich flexibel ist und mit dem `in` Operator etwas an Bord hat, was auch hier nützlich sein könnte.

Also: zeig' mal bitte den realen Code bzw. zumindest alle relevanten Sektionen davon.

Gruß, noisefloor

[Quicktrader]

Hm..ich poste gerne einen Ausschnitt, jedoch wird das vmtl. nicht viel weiterhelfen..im Grunde setzt das Programm verschiedene Bausteine aus Buchstaben (oder Worten) zusammen. Manchmal 'iteriert' dieses über verschiedene Listen (probiert alle aus), jedoch ist Iteration der falsche Begriff - da Text und nicht Zahlen. "Struktur" ist somit doch z.B. ein ganzer Satz (bzw. ein ganzes Wort). Die dazugehörigen Funktionen bzw. das Programm an sich funktioniert durchaus; ist somit auch keineswegs "falsch". Auch habe ich nie geschrieben, Variablen auf der Modulebene angeführt zu haben.

INNERHALB einer Funktion habe ich jedoch stets den Eindruck, limitiert zu sein: So etwa dahingehend, dass innerhalb einer Funktion keine andere Funktion und/oder While-Loop eingegeben sein kann? Oder etwa dahingehend, dass nur EIN Ergebnis ausgegeben wird (anstatt z.B. alle Vokale durchzuprobieren und dann auch alle Ergebnisse auszuspucken). Auch als Array kann ich Text nicht einfach so gestalten bzw. weiterverarbeiten. Vielleicht irre ich mich, aber schon sobald ich "for b,c in...." aus dem Mainprogramm in die Funktion integriere, erhalte ich Fehlermeldungen. Auch will ich z.B. nicht nur eine Funktion innerhalb einer solchen Funktion haben (um z.B. Strukturtext 1 zusammenzustellen), sondern diese mehrfach ausführen (z.B. 10x mit der Funktion auf verschiedene Bausteine des Alphabets zugreifen). While-Loop mit Funktion innerhalb einer Funktion sozusagen..

Aber selbst wenn: Es sollte doch irgendwie möglich sein, statt so...

VARIANTE I

Code: Alles auswählen

if Bedingung1
......if Bedingung2
.............if Bedingung 3

....eben so vorzugehen...

VARIANTE II

Code: Alles auswählen

if Bedingung 1
> Ergebnis1

if Bedingung 2
> Ergebnis2

If Bedingung 3
> Ergebnis 3

Der Unterschied sollte nun doch erkennbar sein. Auch denke ich, braucht man hierzu nicht zu sehr in den Code an sich reingehen (oder diesen hübsch darzustellen [da kein Realcode..aber bitte]). Das Beispiel sollte anschaulich genug sein: In Variante I ist es schlicht so, dass ich "immer mehr einrücken muss" (was m.E. auf die Performance geht, da die dritte Bedingung nicht nur selektiert, sondern für alle (!) ersten, alle zweiten etc. if-Klauselfälle angewendet wird; auch für die 'Erfolglosen'). OBWOHL die Selektion durch IF erfolgt. Außerdem ist mit Variante 1 keinesfalls Multithreading, Verschieben der einzelnen Teilbereiche o.dgl. möglich.

Im zweiten Beispiel könnten die "Tasks" dennoch abhängig (vom Ergebnis), aber nicht innerhalb der ersten beiden IF-Klauseln durchgeführt werden; etwa wenn lassen sich diese schlicht nacheinander ausführen. Ein Programm soll ja auch nicht aus einer gigantischen hunderte Seiten langen Verschachtelung, sondern besser einzelnen Bereichen bestehen (z.B. bei einer Firma mehrere Bestandteile des Programms für verschiedene Abteilungen), ungeachtet der jeweils gegebenen/gewünschten Funktionen bzw. späteren Zusammenführen von Ergebnissen?

Eine Teilung des Gesamtprogramms 'um jeden Preis', sozusagen - eigentlich trivial..oder nicht?

Bitte um Verständnis, das Programm im Detail zu erklären würde vmtl. Tage/Wochen dauern (und soll daher auch hier nicht reproduzierbar sein - es geht lediglich um obige Aufteilung...man erkennt am Ausschnitt jedoch, wie weit das Programm immer mehr einrückt, unsinnigerweise).

Danke für jede zielgerichtete Unterstützung, die Unterteilung eines Programms in mehrere Teile betreffend (übergeordnet zu einzelnen Funktionen, Loops, Variablen etc.).

Quicktrader

Ausschnitt:

Code: Alles auswählen

        if int(len(get_keywords_found(chain1))) >0:

            jj = 0
            for jj in range(100):
                Optrip = trigmiddle_(p)[0] #50 values
                O = Optrip[0]
                trip = Optrip[2]
                UV = bigend_(V)[0] #26 values (weighted)
                U = UV[0]
                AJ = bigstart_(A)[0] #26 values (weighted)
                J = AJ[1]
                klF = random.choices(list(bigrams_short))[0] #50 values
                kl = klF[0]
                F = klF[1]
                FBy = trigstart_(F)[0] #50 values
                B = FBy[1]
                y = FBy[2]
                dash = random.choices(list(alphabet), weights=(8.2, 1.5, 2.8, 4.3, 13.0, 2.2, 2.0, 6.1, 7.0, 0.15, 0.77, 4.0, 2.4, 6.7, 7.5, 1.9, 0.095, 6.0, 6.3, 9.1, 2.8, 0.98, 2.4, 0.15, 2.0, 0.074))[0] #26 values
                jj+=1

                #chain2
                chain2 = chain2_(kl,FBy,dash) #line 10 count: 17 ll+U+V+pl+A+J+pl+O+p+trip+kl+F+B+y+dash+U+pl+R
                if int(len(get_keywords_found(chain2))) >1:

                    pos_numbers1 = re.findall('([0-99]+)', str(get_keywords_found(chain2)))
                    diff1 = int(pos_numbers1[1]) - int(pos_numbers1[0])
                    if diff1 >5:
                        print(ii, "Level Z -", pl, chain1, dash+"_"+chain2, get_keywords_found(chain1), get_keywords_found(chain2))

                        kk = 0
                        for kk in range(400):
                            squliVmoonli = trigmiddle_(V)[0] #50 values
                            squli = squliVmoonli[0]
                            moonli = squliVmoonli[2]
                            tribl = random.choices(list(alphabet), weights=(8.2, 1.5, 2.8, 4.3, 13.0, 2.2, 2.0, 6.1, 7.0, 0.15, 0.77, 4.0, 2.4, 6.7, 7.5, 1.9, 0.095, 6.0, 6.3, 9.1, 2.8, 0.98, 2.4, 0.15, 2.0, 0.074))[0] #26 values
                            kk+=1

                            if 1>0: #if tribl+squli+V in trig1000 and p+O+pl in trig1000: #and A+ll+tribl in trig1000 and tribl+R+A in trig1000:

                                #chain3
                                chain3 = chain3_(squliVmoonli, tribl) #line 4 count 14 p+p+trip+A+ll+tribl+squli+V+moonli+p+O+pl+pl+R
                                if int(len(get_keywords_found(chain3))) >0:
                                    print(ii, "Level Z -", pl, chain1, dash+"_"+chain2, chain3, get_keywords_found(chain1), get_keywords_found(chain2), get_keywords_found(chain3))

                                    yy = 0
                                    for yy in range(400):
                                        dCk = trigend_(k)[0] #50
                                        d = dCk[0]
                                        C = dCk[1]
                                        yy+=1

                                        #chain4
                                        chain4 = chain4_(dCk) #line 6 count: 14 k+sl+p+tribl+R+A+F+ll+O+dash+squli+d+C+k+F+gr
                                        if int(len(get_keywords_found(chain4))) >0:
                                            #pos_numbers2 = re.findall('([0-99]+)', str(get_keywords_found(chain4)))
                                            #diff2 = int(pos_numbers2[1]) - int(pos_numbers2[0])
                                            if 1>0: #if diff1 >4:

[noisefloor]

Hallo,

jedoch wird das vmtl. nicht viel weiterhelfen..

Korrekt, weil immer noch der Kontext fehlt... Plus das die Variablennamen ziemlich nichtssagend sind und man deshalb beim Lesen des Codes anhand dessen auch nicht ableiten kann, was das passieren soll. Die ersten beiden Zeilen enthalten übrigens direkt überflüssige Sachen: `len` liefert einen Integerwert zurück, das `int` ist überflüssig. `jj` muss nicht "initialisiert werden", ein `for jj in index(100):` funktioniert auch so.

jedoch ist Iteration der falsche Begriff - da Text und nicht Zahlen.

Das ist: Quatsch. Python kann über Text iterieren - aber nicht über Zahlen. Über was man in Python alles iterieren kann: https://docs.python.org/3/glossary.html#term-iterable.

So etwa dahingehend, dass innerhalb einer Funktion keine andere Funktion und/oder While-Loop eingegeben sein kann?

Kannst du doch... Du kannst Funktionsaufruf prinzipiell beliebig tief verschachteln. Und ein while-Loop funktioniert auch in einer Funktion.

Oder etwa dahingehend, dass nur EIN Ergebnis ausgegeben wird

Funktionen können beliebig viele Rückgabewerte haben, Datenstrukturen zurück geben oder - allgemeiner - Objekte.

Auch als Array kann ich Text nicht einfach so gestalten bzw. weiterverarbeiten.

Wirklich ein Array? Das ist eher selten in Python, Listen und Tuple sind gängiger. Und natürlich kannst du Text in eine Liste packen. Du kannst ziemlich einfach einen Satz an den Leerzeichen zerlegen und jedes Wort als Element in eine Liste packen. Oder ein Wort in Buchstaben und jeden Buchstaben als Element in eine Liste.

Vielleicht irre ich mich, aber schon sobald ich "for b,c in...." aus dem Mainprogramm in die Funktion integriere, erhalte ich Fehlermeldungen.

Dann ist da halt wohl ein Fehler drin... das schöne an Python ist ja, dass man einen sehr ausführlichen Stacktrace bekommt und die neueren Python-Release die Fehlerstelle sogar - wenn möglich markieren. Vielleicht möchtest du mal die _volle_ Fehlermeldung hier posten. Also 1:1 kopieren, nicht in Volltextprosa beschreiben.

In Variante I ist es schlicht so, dass ich "immer mehr einrücken muss"

Was stark dafür spricht, dass die Struktur deines Programms schlicht schlecht ist. Wurde ja schon gesagt.

das Programm im Detail zu erklären würde vmtl. Tage/Wochen dauern

Was stark dafür spricht, dass das alles zu umständlich programmiert ist. Im Idealfall ist Code selbsterklärend.

Und da du ja weiterhin beharrlich verschweigst, was du eigentlich vorhast, orakle ich mal folgendes: du versuchst irgendwie irgendein Problem "brute force" zu lösen. So sieht der Code nämlich aus. Mögliche Lösungsansätze: a) die Rechenleistung massive hochfahren und damit die Laufzeit des Codes reduzieren, b) bessere Algorithmen für das Problem suchen, c) bestimmt Fälle, die nicht auftreten können, von der Prüfung ausschließen. Letzteres ist einfacher, wenn man das Programm eben nicht tief verschachtelt.

Gruß, noisefloor

[Quicktrader]

Hallo...möchte da jetzt nicht beratungsresistent wirken, aber Deine Antwort ist wenig hilfreich...das Programm würdest Du vlt. verstehen, jedoch nicht was dahinter steht; ist für Dich, mit Verlaub, auch nicht von Relevanz. Bitte daher bei der Sache zu bleiben: Erstens habe ich keine Fehlermeldung, das Programm an sich funktioniert. Auch dass es 'einfacher' ist, wenn man das Programm 'eben nicht tief verschachtelt' ist mir klar, das ist ja genau der Zweck meiner Anfrage. Dennoch ist ein Programmteil manchmal größer als eine einzelne Funktion?

Die Rechenleistung (Thema??) ist vorgegeben; es macht auch keinen Sinn über einen neuen PC - meiner ist zufriedenstellend - nachzudenken, solange das Programm noch nicht einmal optimiert bzw. ideal aufgesetzt ist. Auch Algorithmus (Aho-Corasick) usw. funktioniert..ansonsten schlank und übersichtlich programmiert, bis eben auf Genanntes. Bruteforce: Nein - eher Textgestaltung.

Ziel ist also einzig die angestrebte Umgestaltung (Einzelne Komponenten vs. Verschachtelung; siehe zuletzt). Danke für den Hinweis, dass Funktionen, Whileloops etc. doch innerhalb Funktionen funktionieren sollten - das werde ich ausprobieren.

Wie dem auch sei, man kann alles diskutieren - mich interessiert va. der Lösungsansatz wie man - übergeordnet zu einzelnen Funktionen - größere Teile eines solchen Programms unterteilen kann (ohne diese in eigene .py Dateien zu trennen / Ergebnisse in externe Dateien zu schreiben). Oder - wie eben als ungünstig erkannt - tief verschachtelt zu lassen (tiefer, tiefer, tiefer...ist unsinnig). Wenn keine bessere Idee, werde ich einfach weiter an den Funktionen bleiben...allerdings erschienen mir diese bisher zwar sachgemäß für einzelne Aufgaben des Programms, nicht jedoch für ganze Abschnitte inkl. Loops, Funktionen, Ergebnismengen/-listen etc. ('Variante I' vs. 'Variante II').

Wie hieß es früher so schön? GoTo Zeile....Variante 1...dachte modulares Programmieren wäre eigentlich mit Python kein Problem.

QT

[Quicktrader]

Oder ich schaue mir das Thema der Koroutinen nochmal genauer an..danke dennoch für die gedankliche Anregung (und den neuen PC).

[sparrow]

@Quicktrader: Also falls du daran zweifelst: In meinen Augen ist das beratungsresistent. Du schreibst hier lange Prosatexte, kannst dein Problem aber nicht darlegen. Du bekommst anhand deiner Ausführungen Antworten, die passen dir aber nicht, weil du dir da irgend eine eigene Interpretation aufgebaut hast die - so scheint es mir - schon mit der Realität kollidiert.

Wie man ein Programm in Python strukturiert wurde ja bereits gesagt. Ansonsten hilft einfach mal bekannte Projekte auf github anzuschauen um ein Gefühl dafür zu bekommen, wie man in Python programmiert und strukturiert.
Ansonsten bin ich voll bei noisefloor.

[__blackjack__]

@Quicktrader: Ich bin mir gerade unsicher ob das alles ernst gemeint ist, oder ob Du trollst. Du sagst Du bekommst einen Fehler, wirst nach der konkreten Fehlermeldung gefragt, und antwortest darauf „Erstens habe ich keine Fehlermeldung, das Programm an sich funktioniert.“ Was denn nun?

Dann die ``for``-Schleifen über `range()`-Objekte in denen vorher die Schleifenvariable initialisiert wird und am Ende des Schleifenkörpers manuell hochgezählt wird. Und die Annahme das Schleifen in Funktionen nicht funktionieren würden‽ Du verarscht uns doch hier.

Und zu Variante I und Variante II: Ja kann man beides schreiben, es bedeutet aber beides was anderes. Wäre ja auch komisch wenn so eine unterschiedliche Struktur das gleiche bedeuten würde.

Und dann die Namensgebung… Das kann nicht ernst gemeint sein. Entweder solltest Du weniger von dem nehmen was Du so einwirfst, oder vielleicht solltest Du mal über eine Behandlung nachdenken.

[noisefloor]

Hallo,

Dennoch ist ein Programmteil manchmal größer als eine einzelne Funktion?

Der Satz ist ja totaler Quatsch, weil beides alleine du bestimmen kannst.

möchte da jetzt nicht beratungsresistent wirken,

Tust du auch nicht. Die Resistenz beginnt bei dir schon, bevor man überhaupt beraten könnten, weil du dein eigentliches Problem gezielt verheimlichst. Sowas gibt es (hier im Forum) ja immer mal wieder und besonders bei Problemen wie diesem, wo es scheinbar um Mustererkennung in Zeichenketten geht, erweckt das immer stark den Eindruck, dass da was illegales wie das generieren von Passworten für unerlaubte Zugangsversuche hinter steht. Halte ich auch hier für ein realistisches Szenario.

Oder halt über Weihnachten langweile hattest und versuchst, ein bisschen zu trollen.

Na ja, jedenfalls: viel Glück noch. Kannst deine Lösung ja mal posten, falls du je eine findest.

Gruß, noisefloor

[grubenfox]

Wie dem auch sei, man kann alles diskutieren - mich interessiert va. der Lösungsansatz wie man - übergeordnet zu einzelnen Funktionen - größere Teile eines solchen Programms unterteilen kann (ohne diese in eigene .py Dateien zu trennen

Funktionen und Klassen zum einen (lassen sich alle in eine .py-Datei schreiben), Module zum anderen (sind eigene .py-Dateien)

[Quicktrader]

Hallo ist bei Euch noch alles in Ordnung??

@sparrow: Keine Prosatexte / eigene Interpretation. Der Unterschied zwischen Variante I und II lässt sich kaum einfacher darstellen..auch nicht mit Github.
@_blackjack_: Meine Namensgebung ist Königswerk - muss nicht für Dich funktionieren. Programm läuft; 'verarschen' tust Du Dich also bestenfalls selbst.
@noisefloor: Doch, manchmal IST ein Programmteil größer als eine Funktion. Also kein 'Quatsch'. Selbst wenn Dich Dein Hirn noch so anschreit ("illegales"), lass Dir gesagt sein es gibt historische Chiffren, AI Textgestaltung etc..lösch' also mal Deine Vermutungen: Nur weil Du kriminelle Energie hast, gilt das nicht für andere.

Eine Antwort kam, bis auf den Hinweis bei den Funktionen zu bleiben, bisweilen nicht (war wiederum nicht ganz exakt die Frage). Bitte daher die bisher ach-so freundlichen: Zip-it.

Grubenfox: Danke, werde ich mir anschauen ob sich eine Unterteilung in Klassen anbietet.

Manchmal fragt man sich schon..

QT
(closed)

[sparrow]

@Quicktrader: Naja, das sind schon sehr lange Texte, in denen du sehr voel schreibst aber dein Problem nicht ausformulieren kannst. Und ich denke, wenn du deine Namensgebung als "Königswerk" siehst, dann hast du in meinen Augen wirklich ein Problem. Und wenn das so tief sitzt, dann braucht man über die Strukturierung von Programmen nicht sprechen, weil schon die Basics fehlen.

There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors.
-- Leon Bambrick (angelehnt an Phil Karlton, afaik)

[Quicktrader]

@sparrow: Meine Frage war klar formuliert, auf Nachfrage präzisiert (Variante 1 vs. Variante 2). IHR wolltet den dahinterliegenden Code sehen. Du kommentierst dazu (why?? why???) nur mit Müll, laberst nur von 'Prosatexten' und 'Realität'. Ist nicht schwer zu erkennen, wenn einem ein arroganter Möchtegerntyp schreibt.

Solltest Dich fragen, inwiefern Du überhaupt auf die Frage eines Newbies eingehen solltest (mein Rat: tu's besser nie wieder). Python gehört nicht Dir allein und eine (hilfreiche) Antwort hattest Du nicht. Außerdem ist der Thread bzw. meine Anfrage 'closed'; aufgrund fehlender Netiquette/Sachlichkeit. Von so einem D.. wie Dir will man keine Hilfe, bist ja nicht der Berufsschullehrer. Schädlich für Python, ungut für Newbies, daher just zip it und schreib künftig erst, wenn Du die Antwort weißt.

[Quicktrader]

@sparrow: Meine Frage war klar ausformuliert ("einfachste Aufteilung des Main Programms"); auf Nachfrage präzisiert (Variante 1 vs. Variante 2). Wie deutlich soll ich noch schreiben, dass ich mein Programm einfach unterteilt haben will; mit zahlreichen Funktionen, Loops etc. darin? Kann ich nichts dafür wenn Du das nicht verstehst bzw. mir nicht klar war, dass man nicht modular arbeiten kann, ohne sich auf Funktionen zu beschränken (bzgl. Klassen werde ich noch sehen). Du wolltest den dahinterliegenden Code sehen..warum..um ihn zu verbessern? Wozu, wenn ich diesen komplett umbauen will? Und dann kommt Gemeckere über die Namensgebung meiner Variablen, die Du nicht mal kennst - echt jetzt??

Du kommentierst natürlich just nur zum Code - anstatt nur ansatzweise zu verstehen (why?? why???), redest von Listen und Konstanten - alles ungefragt - sowie 'Prosatexten' und 'Realität' (weil Du keine Antwort hast, simple is that..auf "Klassen" bist Du nicht weiter eingegangen (auch fraglich ob passend). Es würde sich ja 'quasi von alleine' ergeben..sorry, aber weniger Inhalt geht nicht. Bzw. was genau verstehst Du am Wort 'Newbie' nicht?

Solltest Dich fragen, ob Du überhaupt auf Fragen eingehen solltest (mein Rat: tu's besser NICHT). Der Thread bzw. meine Anfrage ist 'closed'; aufgrund fehlender Sachlichkeit/Netiquette. Leute wie Du sind schädlich für Python, ungut für Newbies - daher just zip it (und schreib künftig erst, wenn Du eine Antwort hast..aber im Grunde, bei Deiner Art, besser gar nicht). Nimm die Kritik so wie sie ist.

QT

[einfachTobi]

><((((*>

[__blackjack__]

@Quicktrader: Folge doch einfach Deinem eigenen Rat und halt einfach die Klappe. Das wird hier nix, Du willst ja gar keine Hilfe. Funktionen nicht verstanden haben, aber über Klassen nachdenken. Netter Humor.

[Quicktrader]

1. Verwarnung wegen Beleidigung. Beim zweiten Mal fliegt der User Quicktrader!

- Damaskus

[__blackjack__]

@Quicktrader: Ach so, das wusste ich noch nicht, dass man kompliziertere Sachen einfach durch den Zusatz „Trivialste Frage“ total einfach machen kann. Den Trick muss ich mir merken.

Du beschreibst, dass Du Dich bei Funktionen limitiert fühlst, weil Du den Eindruck hast, dass man da keine Funktionen aufrufen kann, und das in ``while``-Schleifen dann wohl irgendwie auch nicht ginge. Solche Einschränkungen gibt es nicht, also musst Du da irgend etwas nicht oder falsch verstanden haben. Und bevor das nicht geklärt ist, macht es nicht wirklich Sinn mit Klassen den nächsten Schritt an Komplexität anzugehen.

Und auch bei der ganz grundsätzlichen Logik, also einfaches ``if`` hapert es mit dem Verständnis was Code-Struktur und Bedeutung angeht. Denn

Code: Alles auswählen

if bedingung_a:
    ...
    if bedingung_b:
        ...
        if bedingung_c:
            ...

*kann* man nicht in der Form

Code: Alles auswählen

if bedingung_a:
    ...

if bedingung_b:
    ...

if bedingung_c:
    ...

schreiben, denn in der ersten Variante hängen die Bedingungen voneinander ab, also das ``if bedingung_c:`` wird überhaupt nur ausgeführt wenn `bedingung_a` wahr war. Während in der zweiten Variante die Bedingungen unabhängig geprüft werden, also ``if bedingung_c:`` auch ausgeführt wird wenn `bedingung_a` unwahr war.

Die Struktur spiegelt den Ablauf wieder und der verändert sich bei Strukturveränderung. Das Programm macht dann etwas anderes als vorher. Und das ist ja auch gut so, dass man an der Struktur „verschachtelte, abhängige Bedingungen“ vs. „sequentielle, unabhängige Bedingungen“, leicht den Unterschied im Programmablauf erkennen kann.

Was man *vielleicht* machen kann, wenn die einzelnen Prüfungen und Verarbeitungsschritte sich in Funktionen herausziehen lassen, ist eine Schleife über Prüfungen und Verarbeitungen zu schreiben.

Code: Alles auswählen

for prüfe_bedingung, verarbeite in [
    (prüfe_bedingung_a, verarbeite_a),
    (prüfe_bedingung_b, verarbeite_b),
    (prüfe_bedingung_c, verarbeite_c),
]:
    if not prüfe_bedingung(<daten>):
        break

    <daten> = verarbeite(<daten>)

Eventuell mit einem ``else``-Zweig wenn man Code braucht, der ausgeführt wird, wenn alle Prüfungen positiv waren, also die Schleife ohne Abbruch bis zum Ende durchgelaufen ist.

Ansonsten würde man bei zu tiefen Verschachtelungen ganz allgemein einfach anfangen Code daraus, nach Einrücktiefe, in Funktionen auszulagern. Bis man keine zu tiefen Verschachtelungen mehr im Quelltext hat. Wo genau man da ansetzt die Aufteilung zu machen, hängt von der Bedeutung der einzelnen Ebenen ab. Man muss den Funktionen dann ja einen sinnvollen Namen geben können.