Egoist

Hallo Wiener, sicherlich ist es ok, Gültigkeitsabfragen out zu sourcen (grässliches Deutsch), dann gibt es intern keinen Overhead. Halt, Stopp! Ich hatte doch schon mit grosser Mühe herausgefunden, dass "conda" die "kivy 1.10.1" lauffähig sortiert kriegt. Weil ich das aber im Systemumfeld gestartet hatte , gab es Rückschritte beim Navigator und bei Spider. Das muss man nicht so machen, die Installation gehört in ein virtuelles Umfeld. Hätte ich mich nicht heute um Alberts tkinter-Problem gekümmert, wäre ich dort evtl schon weiter. Gruss vom Ego

Hier nun mein modifizierter Code, bitte dafür die Tutorials von Frederik Weitz ansehen (zwinker). from tkinter import * from tkinter.scrolledtext import * from tkinter.ttk import Combobox # Vorbelegung einer Liste mit allerhand einzelnen Strings, die schliesslich in der Combobox landen werden. comboliste = ["Hallo ", "Albert!\n\n", "Das ", "ist ", "mein ", "erster ", "Text.\n", "Der ", "ist ", "noch ", "kurz."] comboliste += ["\n\nDas gelbe Feld ist ein Eingabefeld."] comboliste += ["\nEingaben dort mit <Return> beenden."] comboliste += ["\nBitte die Combobox (rechts) vorher"] comboliste += ["\nund nachher genau durchsehen..."] # hier wird nur ein langer String (Zeichenkette) daraus gemacht. volltext = " ".join(comboliste) def set_in(event): # Diese Funktion wird bei Eingabe von <Return> im Entryfeld (gelb) aufgerufen. global comboliste # Das ist nicht sehr sauber, die Liste wird aus dem globalen Kontext abgesaugt. global cb # ebenso die Combobox, das geht sicher alles besser. zettel.insert(END, "\n" + e.get()) # Pipifax es wird der Inhalt des Entryfeldes (e) angehängt. comboliste = (zettel.get("1.0", END)).split() # interessanter, alle Worte im Textfeld werden in eine Liste überführt. print(comboliste) # die kann man auf der Console nun begutachten. # Jetzt kommt die Wurzel des Übels, welche Albert gequält hat, wie ein fauler Zahn. # Wir haben zwar etwas unschönes gemacht, um in der Definition an die Combobox zu gelangen, # aber es demonstriert die grundsätzliche Vorgehensweise. cb['values'] = comboliste # Die Combobox hat eine für mich auch noch seltsame Eigenschaft, # da das wie ein Listenindex aussieht, dürfte 'values" intern # auch einem Integer entsprechen. # Immerhin kann man mit dem String "values" als Index auf das Objekt ComboBox schreibend zugreifen. # Das scheint es gewesen zu sein... return root = Tk() # Falls es zu dem folgenden noch Fragen gibt, Tutorial gucken und dann hier fragen... frame1 = Frame(root) frame1.pack(fill=X) e = Entry(frame1, width=20, bg="yellow") e.bind("<Return>", set_in) e.pack(side=LEFT) cb = Combobox(frame1, height=5, width=15, values=comboliste) cb.pack(side=LEFT) zettel = ScrolledText(root, bg="white", width=50, height=20, font="Arial 10") zettel.pack() zettel.insert("1.0", volltext) zettel.tag_config("fett", font=("Georgia", "10", "bold")) root.mainloop() Viel Spass mit Python wünscht Ego

Bitte, bitte Albert! Bitte nicht den Sand in den Kopf stecken!!! Als ich das gelesen habe, war ich noch zuversichtlich, es mit ein paar Zeilen Code hinzukriegen, denn ich dachte man könne den Namen einer Liste übergeben und gut ist. Leider wird nicht der Name in values referenziert, sondern der aktuelle Inhalt der Liste wird übernommen. Solche Verständigungsprobleme wird es zu Beginn immer wieder geben. Bitte quäle Dich dann nicht so lange im stillen Kämmerlein, bis zur totalen Aufgabe. Poste lieber Dein Problem hier, oder in einem Pythonforum (für bessere Antworten). Obwohl ich nicht verstehe, was eine Combobox mit 3000+ Zeilen für den Anwender bringen kann, habe ich mich sofort um Dein Problem gekümmert. Dabei habe ich auf ein anderes Tutorial zurückgegriffen, aus dem das Gerüst des folgenden *.py besteht. https://www.youtube.com/watch?v=ahtKa4MiJgs&amp;list=PLAy9pyHEMnr0oBS3b4TeEAg49RhnvQQVK Angefangen habe ich in #44 wo es um die Combobox ging. Daher ist noch der "zettel"-Code aus den vorhergehenden Folgen drin. Meinen modifizierten Code spalte ich ab, wegen den Forenproblemen. Viel Spass mit Python, wünscht Ego

Hallo nochmal, ich freue mich über jede praktische Übung hier sehr. Ohne es jetzt schon in PyCharm überführt zu haben, sieht alles ganz ordentlich und lauffähig aus! Zur Übung kann man das so machen und wenn es fehlerfrei ist, kommen die beiden def-Blöcke bitte in Deine Klasse "RouldefWien" in der Datei roulib00.py. Danach kannst Du die Datei unter roulib01rc01.py abspeichern. Deine Übung ginge dann etwa so weiter: import RouldefWien from roulib01rc01 as RdW #RdW ist die hier jetzt gültige Abkürzung (frei wählbar) chance = RdW() # greift auf das eingebundene Modul zurück, der Rest ist dann wie gehabt chance.bestimmen(int(input("Zahl eingeben:"))) print("EC:",chance.rn,chance.pi,chance.mp) Hoffentlich habe ich keine Fehler eingehackt, denn das war nicht aus getestetm Code kopiert. Die Methode "bestimmen()" gehört dann ab sofort zu den neuen Fähigkeiten Deiner Wiener Klasse. Zu meiner numerischen Klasse passt Deine Definition allerdings nicht und ist ihr (noch) unbekannt. Ich gebe aber noch zu bedenken, dass Deine Methode unpassende Parameter mit einem Bauchklatscher quittieren wird. Viel Spass mit Python wünscht Euch Ego

Moin Wiener, es hat mich einen Batzen Versuche gekostet, bis es so halbwegs hingehauen hat. Bestimmt habe ich mir schon im Vorfeld die Hürden selbst tüchtig hoch gesetzt. Kivy 1.10.1 braucht eine Tonne voll anderer Module, die alle zueinander passen müssen. Unangenehmerweise dürfen viele davon nicht die aktuellsten sein. Vermutlich bin ich daher mit dem Pip- Installer so herzhaft gestrandet. In meiner Not habe ich schliesslich Anaconda installiert, was allerdings dauerte. Nach einem Fehlstart, weil ich noch massig Programme auf dem Schirm offen hatte, konnte ich auf der frisch gebooteten Maschine in der Eingabeaufforderung mit einem Einzeiler: conda install kivy -c conda-forge das Problem teilweise lösen. Teilweise nur deshalb, weil sich danach weder der Anaconda Navigator noch Spyder mehr starten liessen. Wer das verhindern will, muss kivy unbedingt in eine virtuelle Umgebung installieren, denn es werden dabei z.T. neuere Libraries durch ältere ersetzt. Das dürfte der Grund dafür sein, dass bei mir der Navigator und Spyder futsch sind. Mit PyCharm konnte ich aber den zurückgelassenen Systeminterpreter mit den kivy-Modulen problemlos einbinden und endlich das kleine s_cript aus o.a. Tut#9 laufen lasen... Du siehst, man bekommt nicht alles geschenkt. Viel Erfolg und zähe Nerven wünscht Euch Ego

Moin nach Wien, vorhin habe ich begonnen ein Tutorialfile einzuhacken (das s_cript aus den o.a.Crashkurs #9) ende aber bei PyCharm auf der Schnauze. Es fehlt eine Anbindung an sdl2 DLL oder so, daher habe ich nach kivy.org mein Systempython beackert und diesen als Interpreter bei PyCharm gewählt. Das brachte keine Besserung. Vorläufig stehe ich mit dem kivy-Paket auf dem Schlauch... Wäre für Hinweise dankbar, Ego

Hallo Wiener, natürlich habe ich auch Kivy schon in der engeren Wahl. Was mich an QT so angemacht hatte, war der Designer. Ob es sowas auch schon für Kivy gibt, weiss ich leider nicht. Falls Du das noch nicht gesehen hast, ist es vielleicht eine Blick wert: https://www.youtube.com/watch?v=F7UKmK9eQLY&amp;list=PLdNh1e1kmiPP4YApJm8ENK2yMlwF1_edq Wenn es gefällt, kannst Du das in Deinen Thread überragen. Kivy hat den Vorteil Touchscreens einzubinden und hat den Anspruch auf grösste Plattformunabhängigkeit. Klar, dass Dich das als Smartphonejunkie besonders anmacht... Bei der ersten Ansicht hatte ich mitgenommen, man müsse auch noch Kivyfiles schreiben, jetzt sehe ich mir das nochmal an. Gruss vom Ego

Meine Wut über den verlorenen Artikel hat sich etwas gelegt, zumal ich auch an der Pythonfront mit hartnäckigen Problemen zu kämpfen hatte. Die Notwendigkeit einer graphischen Benutzeroberfläche(GUI) wird immer dringender, denn ohne sie kann man kein vernünftiges Programm bauen. Meine Suche nach einer erfolgversprechenden Lösung führte mich zu Qt, bzw zu PyQt und dem Tool "designer.exe" Leider ist die Verbindung der GUI mit einem Pythonprogramm noch vergleichsweise knochig, aber der Designer ist schon klasse. Weniger klasse ist aber, dass man ohne Klassendefinitionen in Python nicht weit kommt. Gruss vom Ego

Moin Feuerstein, +1 ist auch wirklich keine Progression, die man lange gegen einen fiesen Rücklauf spielen kann. Sie ist noch nicht einmal sinnvoll für kürzere Spiele, denn die Umsatzrendite geht kontinuierlich zurück. Im Idealfall kommen EC intermittent, also RSRSRSRS, so machst Du mit 3 Stücken Einsatz ein Stück Gewinn. Dauerintermittenz ist aber alles andere als normaler Zufall. Obige RSRSRSRS-Folge ist genau so selten, wie 8xR oder 8xS in Folge. Gehts Du mit +1 nach Verlust (und -1 nach Gewinn) gegen die Permanenz vor und kassierst eine Abweichung von -18, dann machst Du bei der erlösenenden Intermittenz aus 18+19 = 37 Einsatz ein Stück Gewinn. Da wir wissen, dass jedes 37. gesetzte Stück normal an die Bank geht, wissen wir auch, bei Stufe 18 ist der Arsch schon ab. (Eine Ausnahme stellen Tische mit Zeroteilung auf EC dar, da ist es nur jedes 74. Stück) Also ist die +1 eine gänzlich uneeignete Progression überhaupt. Gruss vom Ego

Das ist doch eher kein Problem... Feuerstein kümmert sich seit Jahren um die absolut schlechtesten Verläufe. Wer es nicht einmal mit einer Durchschnitte ins Plus schafft, bleibt besser daheim.

Mir ist gerade wieder eine weitere Lesson zum Thema den Bach herunter gelaufen. Langsam werde ich stinksauer!!! @Paroli macht jetzt was, oder ich bin raus... Tschüss Leute!

Hallo Albert, schön, dass Dir das zusagt. Es spricht aber auch nichts dagegen, den Klassen weitere Tabellen/Listen anzufügen. Speziell bei den numerischen EC-Listen ist aber auch super einfach z.B. das Vorzeichen zu tauschen. Scheinbar ist es Deiner Aufmerksamkeit entgangen, aber die Listen in meiner numerischen Klasse wurden alle mit meinem älteren Pythons_cript erzeugt und nur in die roulib00.py mit copy & paste eingefügt. Die kryptischen Zeichen rund um die einzelnen Pleinzahlen stellen ANSI-Escapesequenzen zur Steuerung eines Terminals dar. https://de.wikipedia.org/wiki/ANSI-Escapesequenz Das täuscht, sicherlich habe ich etwas mehr Zeit aufgewendet, als üblich zur Verfügung steht, weil ich Urlaub hatte. Das ist jetzt aber vorbei und ich werde Eure Mithilfe brauchen, um den Karren zu ziehen. In Wieners Thread habe ich einen Videolink hinterlassen. Der lesende Mathematiker und Informatiker stellt die Irritationen, die durch Python bei Umsteigern generiert werden können, gelegentlich dar. Falls Dir Deine Bücher mal zu schmal werden, guckst Du vielleicht auch mal dort. Leider scheinen die Forenmacher es noch nicht geschafft zu haben, die Migrationsprobleme einzudämmen. Eine Antwort, auf meinen ausführlichen Bugreport an @Paroli habe ich auch noch nicht erhalten. Ich gehe von intensiven Arbeiten auf dieser Ebene aus. Gruss vom Ego

Heute habe ich einen alten "Bekannten" bei Youtube wiederentdeckt, weil ich nach PyQt gesucht hatte. Hier könnt Ihr Euch von einem Lehrprofi in feinstem Deutsch vorhampeln lassen, wie man komfortabel Oberflächen zusammenklicken kann. Für Neueinsteiger (nach der Installation) https://www.youtube.com/watch?v=kWiw7ZArnmc Dies Video fängt recht einfach an https://www.youtube.com/watch?v=ejfQCi2O6Ao Dieses ältere Video hab ich mir gerade angeschaut. https://www.youtube.com/watch?v=XBurh2nBR6c Hier findet sich bestimmt noch mehr wissenswertes. https://www.youtube.com/user/JoernLoviscach/search?query=Python Viel Spass mit Phyton wünscht Euch Ego

Hallo @sachse, da hast Du sehr gut aufgepasst und schön demonstriert, wie man aus Fehlern einen Informationsgewinn erzielen kann.

OK, mein erster Entwurf beinhaltete nur mehr oder weniger die Kesselaufteilung und damit die Spielregeln. Es gibt bisher 2 Klassen, eine alphanumerische und eine numerische. Beide stellen Konstante zur Verfügung, mit denen man evtl etwas reissen kann. Was gänzlich fehlt, ist der Import einer Realpermenenz, das habe ich aber in der Mache. Was ausserdem fehlt ist die Definition einer Permanenz und die eines Coups. Dazu habe ich schon klare Vorstellungen, bin aber noch offen für Input.

Nein, hier ist gar nichts fertig. Ich versuche nur, mich fortzubilden. Wenn ein GUI Scheisse ist, so ist es für mich doch noch besser als nix. Bitte verzeihe mir, aber ich habe schon wieder ewig nix mehr programmiert. Ich muss mich also an alles wieder herantasten. Zu meinen (autodidaktischen) Methoden zählte immer trial & error, was mich immerhin schon nach 2Tagen des Erstbesitzes eines Computers, zum ersten lauffähigen und selbst geschriebenen Computerspiel gebracht hatte. Blöderweise hatte ich da noch keinen Massenspeicher und keinen Drucker. Also musste ich das Programm vom Bildschirm abschreiben, damit es nicht verloren geht, Glücklicherweise konnte ich dann noch die Kohle (199DM) für ein Kassettenlaufwerk beschaffen, um es (entgegen aller Warnhinweise) an den laufenden Computer anzuschliessen. So wurde mein erstes Programm schliesslich gesichert... Wie sollen wir wissen, was fertig ist?

LOL Wiener, aber wie kommen wir hier nun weiter, ohne uns zu verzetteln? Mein Vorschlag wäre tatsächlich erst einmal tkinter ins Boot zu holen, weil es gänzlich plattformunabhängig ist. Mit der kleinen Spielerei auf der Konsole ist kein Blumentopf zu gewinnen. Gruss vom Ego

Wenn Du mir dahingehend helfen könntest, festzustellen wie man Vorteile zwischen 2 Dingen herausfinden kann, werde ich Dir auch antworten können. Oder flacher formuliert: Gib mir einfach einen Vorteil an, der zwischen einem Fisch und einem Fahrrad besteht. Erst dachte ich, Du wolltest hier nur den Troll geben, aber weil Du nochmal nachfragst: Ich gehe nicht davon aus, dass Dir an aktiver Programmierung überhaupt etwas liegt, falls doch, hast Du noch einen weiten Weg vor Dir. Wenn Du in einer Programmiersprache die selbe Schlampigkeit an den Tag legen würdest, wie Du es hier mit der deutschen Sprache machst, kämst Du nicht unfallfrei über die erste Zeile Programmcode hinaus. Das klingt vielleicht besonders spitz, entspricht aber den Tatsachen. Gruss vom Ego

Falls jemand das letzte Codefenster kopiert hatte, bitte erneut holen. Es wurde ein logischer Fehler beseitigt und es wurden Kommentare ergänzt. Natürlich ist das keine sinnvolle Anwendung, sondern demonstriert nur den Zugriff auf eine Klassenmethode. Viel Spass mit Python wünscht Ego

Das folgende macht noch nicht ganz, was ich wollte, aber ich hatte andere Probleme. Es ist aber ein Beispiel dafür, wie man auf unseren Librarycode zugreifen kann, indem man nur die Datei importiert. In PyCharm wird die Konsole nur ca. 5x pro Sekunde neu erzeugt. Das ruckelt wie die Hölle, obwohl der code einen halbwegs weichen Output erzeugen sollte. Ist ja alles noch pre alpha import roulib00 as roullib import time import numpy as np r = roullib.Roulette_franz # Es wird der französische Kessel aus unserer Alpha Library importiert. s = 1 # Drehrichtung Rotor links while True: # es wird ein Rechtswurf der Kugel zuerst angenommen a = -1100 # Abwurfpunkt 1100 Fächer vor der Zero, also fast 10 Rotationen e = -a # theoretisch läuft der Rotor bis dahin also insgesamt ca 19 Umdrehungen while s >= (-1): # nach dem ersten Wurf wurde die Drehrichtung 1x geändert, dann nochmal andersrum print("Kesselgucken für Arme: I") print(" I") print(" V") t = 0.0003 * np.random.randint(0, 37) # die Zeit festlegen, die gebraucht wird nach Abwurf 1 Fach zu passieren f = 1.001 # anfänglicher Reibungswert ff = 0.0001 # dynamischer Reibwert, das ist alles sehr unphysikalisch for i in range(a, e, s): # Schleife in der ein Kesselsegment nach dem anderen angezeigt wird t = t * f + ff # Kugel abbremsen ff = ff * (1 + ff/100) # Reibung verändern r.print_Segment(r, i,i+24, "\r", "") # Segment darstellen (ist eine Methode der Klasse) print (" ",i,t, end="" , flush=True) # ein paar Parameter ausgeben (Fachnummer und Fachgeschwindigkeit) time.sleep(t) # Zeit zwischen 2 Fächern abwarten if t > 0.2 + 0.1 * np.random.randint(0,37): # feststellen, ob Kugel gelandet ist print("\n",r.pl_kessel[(i+6)%37]) # falls ja, Zeilenvorschub Terminal break # Schleife verlassen s -= 2 # Drehrichtung ändern a = a * -1 # Abwurfpunkt ändern. TODO: Auf letztes Trefferfach setzen e = -a # theoretisches Schleifenende s = 1 # nach 2 Läufen Drehrichtung zurücksetzen inp = input("Weiter (enter) Stop mit 'Q': ") # Benutzer fragen, ob es weitergehen soll if inp.upper() == "Q": # nach Eingabe von "q" oder "Q" und ENTER quit() # Programm beenden

Meine Antwort an @roemer wurde nun schon 2h, oder so, von der Forensoftware wirkungsvoll verhindert. Ich erspare Euch die Details, die habe ich @Paroli detailiert geschickt. Selbst wenn man (bestimmte?) Zitate in reinen Text umwandelt und diese dann wieder zu posten versucht, knallt es... Da hilft nicht einmal der <code> Container... Gruss vom Ego (der den heutigen Abend leider mit Debugging der Forensoft vergeudet hat) toxic_phrase.zip

Jetzt hatte ich schon wieder Probleme meine Antwort abzuschicken... Es waren Zitate von roemer darin, und auch ein Link zu seinem Profil (das Ding, welches man bekommt, wenn man @Benutzername tippt). Kommentar der Website: Verboten... Edit: Selbst wenn ich das Posting aus dem Editor herauskopiere und dann als Pleintext in den WindowsEditor einfüge, dort also alle Verweise auf andere Postings in reinen Text verwandele, dann dort den Text wieder herauskopiere und hier einfüge kommt: Fehler 403 forbidden Ich mache jetz noch einen Versuch und logge aus und schliesse den Firefox...

Hier mal mein Entwurf für die erste Version unseres Roulettemoduls "roulib00.py" # Diese Datei bitte als roulib00.py ins aktuelle Arbeitsverzeichnis kopieren. # man kann dann in allen weiteren *.py Dateien auf die Klassenelemente zugreifen, # wenn man sein s_cript beispielsweise mit # # import roulib00 as r # # beginnt. # # r.RouldefWien.kess # # repräsentiert dann ein Tuple mit allen Plein in Kesselfolge im Uhrzeigersinn. # # usw. # # Bei Fragen, bitte fragen... import numpy as np # Definition nach Wiener Art class RouldefWien: kess = (0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20, 14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26) rono = (0,"R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N","R","N") paip = (0,"P","I","I","P","I","P","I","I","P","P","I","I","P","I","P","P","I","P","I","P","P","I","I","P","P","I","I","P","P","I","I","P","P","I","I","P") mapa = (0,"G","K","G","K","G","K","G","K","G","K","G","K","G","K","G","K","G","K","K","G","K","G","K","G","K","G","K","G","K","G","K","G","K","G","K","G") dou = (0, 3, 2, 2, 1, 2, 1, 3, 2, 3, 1, 3, 2, 3, 1, 3, 1, 2, 1, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 3, 1, 3, 1, 3) col = (0, 2, 3, 1, 1, 3, 2, 1, 2, 1, 3, 3, 1, 3, 2, 3, 2, 2, 1, 2, 3, 1, 3, 1, 2, 2, 1, 3, 1, 3, 2, 1, 1, 3, 2, 3, 2) trs = (0, 31, 13, 19, 1, 19, 1, 25, 13, 31, 1, 25, 13, 31, 7, 25, 7, 19, 7, 1, 19, 13, 31, 1, 19, 13, 31, 7, 19, 13, 25, 7, 25, 7, 31, 1, 25) trp = (0, 31, 13, 19, 4, 19, 1, 25, 16, 34, 4, 25, 13, 34, 10, 28, 7, 22, 10, 4, 22, 16, 31, 1, 19, 13, 31, 7, 22, 16, 28, 7, 28, 10, 34, 1, 25) sek = ("Z","Z","Z","G","G","G","G","G","O","O","O","K","K","K","K","K","K","K","K","K","K","K","K","O","O","O","O","O","G","G","G","G","G","G","G","G","G") # Ego's numerische Listen class Roulette_franz(): pl_kessel = [0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20, 14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26] pl_fach = [0, 23, 6, 35, 4, 19, 10, 31, 16, 27, 18, 14, 33, 12, 25, 2, 21, 8, 29, 3, 24, 5, 28, 17, 20, 7, 36, 11, 32, 30, 15, 26, 1, 22, 9, 34, 13] ec_RS = [0, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1] ec_TH = [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1] ec_UG = [0, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1] dc_col = [0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3] dc_duz = [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3] c6_tvs = [0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6] c12_tvp = [0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 12] c9_car = [(0, 1, 2, 3), (1, 2, 4, 5), (2, 3, 5, 6), (4, 5, 7, 8), (5, 6, 8, 9), (7, 8, 10, 11), (8, 9, 11, 12), (10, 11, 13, 14), (11, 12, 14, 15), (13, 14, 16, 17), (14, 15, 17, 18), (16, 17, 19, 20), (17, 18, 20, 21), (19, 20, 22, 23), (20, 21, 23, 24), (22, 23, 25, 26), (23, 24, 26, 27), (25, 26, 28, 29), (26, 27, 29, 30), (28, 29, 31, 32), (29, 30, 32, 33), (31, 32, 34, 35), (32, 33, 35, 36)] c18_che = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 4), (2, 3), (2, 5), (3, 6), (4, 5), (4, 7), (5, 6), (5, 8), (6, 9), (7, 8), (7, 10), (8, 9), (8, 11), (9, 12), (10, 11), (10, 13), (11, 12), (11, 14), (12, 15), (13, 14), (13, 16), (14, 15), (14, 17), (15, 18), (16, 17), (16, 19), (17, 18), (17, 20), (18, 21), (19, 20), (19, 22), (20, 21), (20, 23), (21, 24), (22, 23), (22, 25), (23, 24), (23, 26), (24, 27), (25, 26), (25, 28), (26, 27), (26, 29), (27, 30), (28, 29), (28, 31), (29, 30), (29, 32), (30, 33), (31, 32), (31, 34), (32, 33), (32, 35), (33, 36)] format_Farbe = ['\x1b[1;42;30m 0 \x1b[0m', '\x1b[1;41;37m 1 \x1b[0m', '\x1b[1;40;37m 2 \x1b[0m', '\x1b[1;41;37m 3 \x1b[0m', '\x1b[1;40;37m 4 \x1b[0m', '\x1b[1;41;37m 5 \x1b[0m', '\x1b[1;40;37m 6 \x1b[0m', '\x1b[1;41;37m 7 \x1b[0m', '\x1b[1;40;37m 8 \x1b[0m', '\x1b[1;41;37m 9 \x1b[0m', '\x1b[1;40;37m 10 \x1b[0m', '\x1b[1;40;37m 11 \x1b[0m', '\x1b[1;41;37m 12 \x1b[0m', '\x1b[1;40;37m 13 \x1b[0m', '\x1b[1;41;37m 14 \x1b[0m', '\x1b[1;40;37m 15 \x1b[0m', '\x1b[1;41;37m 16 \x1b[0m', '\x1b[1;40;37m 17 \x1b[0m', '\x1b[1;41;37m 18 \x1b[0m', '\x1b[1;41;37m 19 \x1b[0m', '\x1b[1;40;37m 20 \x1b[0m', '\x1b[1;41;37m 21 \x1b[0m', '\x1b[1;40;37m 22 \x1b[0m', '\x1b[1;41;37m 23 \x1b[0m', '\x1b[1;40;37m 24 \x1b[0m', '\x1b[1;41;37m 25 \x1b[0m', '\x1b[1;40;37m 26 \x1b[0m', '\x1b[1;41;37m 27 \x1b[0m', '\x1b[1;40;37m 28 \x1b[0m', '\x1b[1;40;37m 29 \x1b[0m', '\x1b[1;41;37m 30 \x1b[0m', '\x1b[1;40;37m 31 \x1b[0m', '\x1b[1;41;37m 32 \x1b[0m', '\x1b[1;40;37m 33 \x1b[0m', '\x1b[1;41;37m 34 \x1b[0m', '\x1b[1;40;37m 35 \x1b[0m', '\x1b[1;41;37m 36 \x1b[0m'] # Hier auch eine erste Funktionsdefinition innerhalb der Klasse # der Aufruf erfolgt erst in einen S_cript, welche diese Datei importiert. def print_Segment(self, start, stop, beginn = "\r", ende = ""): step = 1 if start > stop: step = -1 print(beginn, end = "", flush = True) for i in range(start, stop): x = i % 37 if x < 0: x += 37 print(self.format_Farbe[self.pl_kessel[x]], end = "") print(ende, end = "")

Theoretisch sollte es zur Laufzeit möglich sein, dass ein Pythons_cript; seinen eigenen Code erweitert. Ich hab es noch nicht probiert, aber ich denke das müsste klappen: Eine Klassendefinition hatte ich ja schon errechnet und auf die Konsole gedruckt. Diesen Output hätte ich auch direkt in eine xyz.py Datei schreiben können, um sie danach zu importieren. # Programmteil 1: # Hier steht der ganze Code, der die Datei xyz.py ins aktuelle Verzeichnis schreibt # danach kann es im stopp&#33; so weiter gehen import xyz # ab hier stehen alle Objekte und Funktionen, die oben in xyz.py geschrieben wurden # sofort zur Verfügung. # # Sowas geht in keiner Sprache, die vorher kompiliert werden muss... # # Natürlich kann man so auch ein eigenes GUI zur Laufzeit generieren lassen. #

Hallo Albert, schade, dass Dir Python so schwierig vorkommt, die Sprache soll eigentlich zu den einfacher erlernbaren zählen Vielleicht fehlt Dir die gewohnte Vorgehensweise anderer Programmiersprachen in Python. Mir scheint es im Gegensatz zu anderen Sprachen eher so zu sein, dass Python im wesentlich nur aus Quellcode besteht, der selbst in Python geschrieben ist. Vielleicht findest Du einen Vortrag interessant, der sich zwar an fortgeschrittene Phytoniker richtet, aber viel von den Innereien offenbart. Er dauert allerdings 2h und geht sehr langsam los, ich bin auch noch nicht ganz durch https://www.youtube.com/watch?v=7lmCu8wz8ro Fazinierend finde ich zum Beispiel die Idee, das auch Funktionen Objekte sind (falls ich alles richtig verstanden habe). Die kann man dann zum Beispiel als Argument an andere Funktionen übergeben. Oder man kann vielfältige Eigenschaften einer Funktion einfach auslesen, bis hin zum Quellcode oder Anzahl der verwendeten Variablen. Gib doch bitte mal ein Beispiel. Es ist nicht so, dass ich nicht immer noch blutiger Anfänger bin, aber wenn ich helfen kann, will ich das gern versuchen. Mit tkinter hab ich noch nicht mehr gemacht, als das was ich schon gepostet hab. Das Aussehen eines GUI ist mir erstmal Mumpe, wenn es nur funktioniert. Vergleiche ich die Vielzahl an Einstellungen, die zB in .NET nötig sind, um etwas auf den Schirm zu zaubern, ist mir zumindest jetzt noch eine minimalistische Definition lieber. Ups, zu spät gesehen... Darauf möchte ich noch eingehen, obwohl es schon in den # Kommentaren stand: Wenn Du genau hinsiehst, wirst Du feststellen, dass das Programm zunächst der Kopf einer Klassendefinition ausgibt. Die vielen Tabellen, die folgen, sind mit TAB eingerückt und gehören zu der Klasse ( Roulette_franz()). Markierst Du den ganzen Output (abzüglich der Ausgaben von spider) hast Du alle Konstanten in der Klasse. Das ist purer Phytoncode, der in eine Library kopiert werden kann. Ich habe mir dazu die Datei roulib00.py in das aktuelle Arbeitsverzeichnis gespeichert, in der die Klassendefinition eingefügt wurde. Ausserdem stehen dort die Tabellen drin, die @wiensschlechtester erstellt hatte. Die Datei wird meine oder unsere erste Library wenn ihr wollt. Gruss vom Ego