Jump to content

Recommended Posts

Hallo Ego,

 

Dein Code-Snippet für's Permeinlesen funktionierte auf Anhieb.

 

Es geschieht das callback-Wunder Nr. 2: Klickt man auf ein Combobox-Entry, dann wird "callback(entry)' angesprochen.

Dort lasse ich die von Dir codierte Funktion 'print_filename()' rufen (s. Code-Snippet ganz unten).

In 'print_filename' habe ich Deine 4 Zeilen file = open(fn)  ...  file.close() reingesetzt.

Es funktioniert!

Die mit 'print(len(lines))' angezeigte Zahl der lines-Elemente stimmt. Ich kann das ganz schnell mit einem meiner Excel-Programme kontrollieren.

Und das Permlesen geht sehr sehr schnell!

def print_filename():
    fn = dirtext.get()
    fn += "\\"
    fn += combo_1.get()
    print(fn)
    
    parsePermFile = ["CC-Permanenz", "gespeichert", "um", "Gewinnzahlen"]
    sizePF = len(parsePermFile)
    print(sizePF)  
    
    file = open(fn)
    lines = file.readlines()
    print(len(lines))
    file.close()  
        
#    status = 0
#    x = 0
#    perm = []

#    for each in lines:
#       if re.match(parsePermFile[status],lines[x]):
#           temp = lines[x].split(" ")
#           print(x, temp)
#           perm.append(x)
#       x += 1
#    sizePerm = len(perm)
#    print("Gefunden",sizePerm,"\n",perm)    

def callback(entry):    # universelle Ausgabe, als temporäre Debugfunktion
    print_filename()

Die Schlüsselworte für's Parsen habe ich auf meine Kopfzeilen eingestellt, aber es hat nicht geklappt.

 

Dieses Einlesen auf Hauruck mit readlines möchte ich umstellen auf readline in einer Schleife, so dass man auf jede einzelne Zahl Zugriff hat.

Dann kann man die Instanzen der Klasse 'COUP' bilden und Textzeilen (is not numeric(...)) einfach übergehen.

Man ist nicht an feste Parser-Keys gebunden.

 

Das callback-Wunder Nr. 1 - man wechselt das Poolverzeichnis, drückt Enter und die Combobox wird korrekt neu gefüllt - wird durch 'print_filename' nicht gestört.

(Definition: Ein Pool ist ein Verzeichnis mit mehreren Permdateien.)

 

Wir sind wieder einen kleinen Schritt weiter - dank Deiner Vertrautheit mit Python.

Python ist halt eine Wundertüte!

 

Morgen noch 40 m Hecke.

Gute Nacht!

Albert

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 11 Minuten schrieb Dr. Manque:

Python ist halt eine Wundertüte!

 

Morgen noch 40 m Hecke.

Gute Nacht!

Albert

 

 

Gute Nacht Albert!

 

Du wirst es auch morgen nicht bereuen, Dich weiter hartnäckig mit Python beschäftigt zu haben.

Du wirst genauso zufrieden auf die erzielten Erfolge zurückblicken, wie auf Deine geschnittene Hecke.

 

Und Du wirst auch dann wissen, was Du sowieso schon immer wusstest:

"Ohne Schweiss, kein Preis!"

 

---------- Sicherheitspause-------------

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 23 Minuten schrieb Dr. Manque:

Die Schlüsselworte für's Parsen habe ich auf meine Kopfzeilen eingestellt, aber es hat nicht geklappt.

 

Das liegt daran, dass mein Snippet noch gar kein Parser ist.

 

In meinem Beispiel ging ich von einem DL-File aus Wiesbaden aus, in dem viele Tage hintereinander abgespeichert sind.

Alle Tage fangen mit dem ersten (0ten) Element der Parserliste an.

Immer wenn dieses Element im Text auftaucht, wird eine Sektion begonnen und die Zeilennummer festgehalten.

 

Die Wiesbaden-Permanenzen holt man sich hier:

https://www.spielbank-wiesbaden.de/index.php?id=105&view=archiv&table=&date=..#

 

Ausgabetyp stellt man auf Download mit Statistiken.

"von:" sucht man dann mit Klick auf Kalender aus

"bis:" ebenfalls.

Danach noch den Tisch aus der ComboBox...

 

Ich empfehle nicht mehr als einen Monat auszuwählen,

also von: 01.01.2018

bis: 01.02.2018

Tisch: xxx

denn ich habe festgestellt, dass sonst das Dateiende korrumpiert ist, weil eine maximale Dateilänge nicht überschritten werden kann.

 

Nach dem Klick auf Download darf man Nerven bewahren, denn das dauert extrem lange.

Viel später kommt dann die Nachfrage des Browsers, ob geöffnet werden soll, oder gespeichert.

Nun braucht man nochmal Sitzfleisch, weil das Herunterladen wieder ewig braucht.

 

Mit ein paar mehr Fenstern, kann man das aber gleichzeitig auf mehrere Zeiträume anwenden.

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 1 Stunde schrieb Dr. Manque:

wird durch 'print_filename' nicht gestört.

 

Nein, denn Du rufst es in der callback() auf.

Das passiert, wenn Du eine Datei aus dem (gültigen) Verzeichnis in der Combobox angeklickt hast.

 

Ich gehe mal davon aus, dass Deine Permanenzdateien immer nur ein Stück/Tag sind.

Dann ist das Einlesen auch nicht weiter erschwert.

Morgen gibt es das erste Snippet, welches eine Permanenz extrahiert.

Dann werden auch Elemente der Klasse Coup erzeugt werden.

 

Vorher brauchen wir aber noch die Klasse "Permanenzdatei", die hat einen Pfad und beliebig viele Permanenzen in sich.

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 22 Stunden schrieb Egoist:

Morgen gibt es das erste Snippet, welches eine Permanenz extrahiert.

 

Ei, da habe ich mir wohl etwas viel vorgenommen, denn ich wollte sowas wie eine universelle Definitionssprache basteln,

mit der man nicht nur die Daten eines Casinos einlesen kann.

 

Bei der Affenhitze ist mein Hirn gehörig dehydriert und eher im Notlaufprogramm,

daher habe ich mir bisher vergeblich den Kopf zerbrochen.

 

Trotzdem gibt es ein neues Snippet, welches wirklich Zahlen aus Textdateien extrahiert, sofern sie links in der Zeile stehen.

Alle Zeilen, die nicht einer einzelnen  Zahl entsprechen, werden übersprungen.

 

Dazu verwende ich ein neues Modul namens "re".

Das steht für Regular Expressions. Es ist es wert, dafür gezielt Informationen einzuholen.

denn solche regulären Ausdrücke (das ist RE auf deutsch) werden nicht nur in Python verwendet.

 

Zuerst ist das kryptischer Sche*ss, aber wenn man es ganz vorsichtig lernt und nicht gleich alles verstehen will, geht es.

Die Suche nach Strings in Strings ist damit im Nu erledigt.

 

import re                   # Modul für Regular Expressions

coupZahlen = r" *[0-9]"     # der Suchstring beginnt mit einem kleinen "r" vor einer Zeichenkette,
                            # das bedeutet, es folgt eine Regular Expression(re)  (bitte googlen).
                            # Die Expression beginnt mit einem SPACE also Leerzeichen,
                            # gefolgt von einem "*" was 0-n Leerzeichen bedeutet.
                            # Der Ausdruck in den eckigen Klammern besagt, Zeichen von 0 bis 9
                            # werden erwartet.

# parsePermFile ist noch Baustelle, heute wird nur der fünfte Eintrag benutzt.
# das ist parsePermFile[4]
parsePermFile = ["Spielbank Wiesbaden", "Tisch:", "Datum:", "N  Z  R", coupZahlen]
sizePF = len(parsePermFile)
print(sizePF)               # nur zur Info
print (parsePermFile)       # bei ausgefallenen re kann man sehen wie sich das auf coupZahlen ausgewirkt hat

file = open('d:\\Temp\\Permanenzen_SBWB_2018-01-01_Tisch 2.txt') # Pfad bitte an den eigenen Rechner anpassen
lines = file.readlines()    # Alle Zeilen der Datei werden in einem Rutsch eingelesen
print(len(lines))           # Jede Zeile hat nun einen eigenen Listeneintrag in "lines"
file.close()                # Datei schliessen.

x = 0                       # Zeilenzähler auf 0 setzen
perm = []                   # Permanenz löschen

for each in lines:          # Alle Zeilen durchhampeln
    if re.match(parsePermFile[4],lines[x]):     # Hier wird auf eine Zahl nach Regular Expr. geprüft
        temp = lines[x].strip(" \t\n\r")        # war es eine werden Leerzeichen, Tabulatoren etc entfernt
        print(x, temp)                          # zur Prüfung ausgeben
        # Achtung, hier fehlt noch eine Gültigkeitsprüfung!
        perm.append(temp)                       # neue Permanenzzahl speichern
    x += 1                  # nächste Zeile ansteuern

quit()                      # Beendet das Programm hier, denn dahinter ist nur Baustelle
# ----------------------------------------------------------------------------------------


status = 0
x = 0
perm = []

for each in lines:
    if re.match(parsePermFile[status],lines[x]):
        temp = lines[x].split(" ")
        print(x, temp)
        perm.append(x)
    x += 1
sizePerm = len(perm)
print("Gefunden",sizePerm,"\n",perm)
parse = 0
x = 0

 

Viel Spass mit Python

wünscht Euch Ego

 

p.s.: Liest hier noch wer mit? Falls ja, gebt mal Laut und fragt was Euch unklar blieb.

Link zum Beitrag
Auf anderen Seiten teilen
Am 27.7.2018 um 02:20 schrieb Egoist:

 

 

Dazu verwende ich ein neues Modul namens "re".

Das steht für Regular Expressions. Es ist es wert, dafür gezielt Informationen einzuholen.

denn solche regulären Ausdrücke (das ist RE auf deutsch) werden nicht nur in Python verwendet.

 

Hallo Ego,

 

hatte mich schon gewundert, bei Deiner Erstversion, warum Du diesen komplizierteren Weg gehst, einstweilen bräuchten wir es ja nicht (versuche noch mit möglichst wenig Modulen auszukommen)

 

Eine andere Frage, da meine Roulettegeschichten immer ohne auskamen: Sollte man für den einzelnen Coup eine Superklasse erstellen, mit Coup-Nr., Bemerkung, Datum/Zeit, und die Chancenbestimmung als Subklasse?

 

Servus

Link zum Beitrag
Auf anderen Seiten teilen
vor 5 Stunden schrieb wiensschlechtester:

hatte mich schon gewundert, bei Deiner Erstversion, warum Du diesen komplizierteren Weg gehst, einstweilen bräuchten wir es ja nicht (versuche noch mit möglichst wenig Modulen auszukommen)

 

Hallo Wiener,

 

einerseits versuche ich die Möglichkeiten von Python kennenzulernen, andererseits möchte ich sie auch an Euch vermitteln,

indem ich versuche, sie in einfachem, aber möglichst pythonischem Code anzuwenden.

 

Wenn man sehr komplexe Suchanfragen an eine Textdatei hat, drängt sich das re-Modul geradezu auf,

denn es erspart einem Tonnen von Schleifen und Fallunterscheidungen.

 

Sicherlich erscheint es für Dich als massiver Overkill, da in dem Snippet tatsächlich nur nach Zahlen am Zeichenanfang,

mit und ohne führende Leerzeichen gesucht wird.

 

Im älteren Snippet wurde dagegen mit fast dem gleichen Code eine Riesendatei in einzelne Tage unterteilt,

und in der Liste mit den parsePermFile-Suchbegriffen stehen schon weitere Suchbegriffe,

die der Reihe nach abgearbeitet werden sollen.

 

Mir schwebt also ein Importmodul vor, das man mit einer einzigen Liste füttern kann

und dass dann entweder einen, oder mehrere Permanenztage als Liste zurück gibt.

 

Im Falle Wiesbaden startet jeder Tag mit "Spielbank Wiesbaden", also wird die eingelesene Datei immer dort abgeschnitten.

Es folgt das Suchwort "Tisch:" und dahinter steht im Text der Tischname.

Anschliessend kommt das Datum nach Suchwort "Datum:",

und nach "N  Z  R" geht es mit den Coups los.

 

Diese werden durch Handwechselmarken "-- -- --" unterbrochen und mit einer leeren Zeile beendet.

 

Gäbe es weitere Casinos mit diesem Format, könnte man "Spielbank Wiesbaden" durch "Spielbank " ersetzen

und man müsste nur das 2. Wort in dieser Zeile als Ortsangabe speichern.

 

Weitere, völlig andere Formate, würden nur eine andere Suchwortliste benötigen,

um zum selben Resultat zu kommen.

 

Vielleicht gelingt es sogar, diese Suchwortliste interaktiv am Bildschirm zusammenzuklicken,

das wäre mal richtig kommod.

 

Zitat

Eine andere Frage, da meine Roulettegeschichten immer ohne auskamen: Sollte man für den einzelnen Coup eine Superklasse erstellen, mit Coup-Nr., Bemerkung, Datum/Zeit, und die Chancenbestimmung als Subklasse?

 

 

Da weiss ich leider keine Antwort.

Welchen Vorzug hätte eine Subklasse?

 

 

Gruss vom Ego

 

bearbeitet von Egoist
Link zum Beitrag
Auf anderen Seiten teilen
vor 17 Stunden schrieb Egoist:

einerseits versuche ich die Möglichkeiten von Python kennenzulernen, andererseits möchte ich sie auch an Euch vermitteln,

indem ich versuche, sie in einfachem, aber möglichst pythonischem Code anzuwenden.

Hallo Ego,

 

diese löbliche Einstellung ist mir schon aufgefallen, ging halt immer den einfachsten Weg, somit werde ich wohl lang brauchen bis ich drin bin (mein Python-Notizbuch füllt sich langsam), finde es trotzdem sehr interessant wohin die Reise gehen kann.

 

Somit hat die Roulettegeschichte noch einen positiven Lerneffekt. Vor langer Zeit steigerte ich z.B. damit meine Excel-Kenntnisse welche ich auch beruflich gut einsetzen konnte.

 

vor 17 Stunden schrieb Egoist:

Sicherlich erscheint es für Dich als massiver Overkill

Oh ja, doch siehe oben. Sehe auch erst nach Fertigstellung der ganzen Arbeit erst die Chance dass vielleicht noch einige mehr mitmachen, da es dann wesentlich einfacher ist.

 

vor 17 Stunden schrieb Egoist:

Welchen Vorzug hätte eine Subklasse?

 

Nun ja, bin dafür leider nicht der Richtige um dies zu beantworten. Mein Gedankengang war folgender:

 

Wir haben mehrere Coups - eh klar. Für jeden einzelnen Coup müssen wir die gefallenen Chancen bestimmen, sowie die Prognosen und Treffer/Nichttreffer bestimmen. Wenn man schon mit Klassen anfing...

 

Servus

 

 

 

Link zum Beitrag
Auf anderen Seiten teilen

Hallo Ego,

 

Durch 'Enkel-Betreuung' war ich 2 Tage außer Gefecht gesetzt.

Heute habe ich mich stundenlang mit .isdigit(), .lstrip() und .isalnum() herumgeärgert.

Ich wollte beim Thema "Permanenz extrahieren" ohne 'if re.match(parsePermFile[status],lines[x]):' auskommen (verzeih mir!).

 

Am Schluss hat es geklappt. (Und es war im Grunde auch wieder ganz einfach.)

def print_filename():
    fn = dirtext.get()
    fn += "\\"
    fn += combo_1.get()
    print(fn)
    
    file = open(fn)
    lines = file.readlines()
    print(str(len(lines)) + " Permlines gefunden.")
    file.close()  
        
    x = 0
    tx = 0
    perm = []

    for each in lines:
        ti = lines[x].rstrip()  # Escapes und Blanks herausnehmen
        
        try:
            i = int(ti) 
#            print(i)
            perm.append(i)             
            
        except:
            tx += 1
#            print("Textzeile:" + ti)
            
        x += 1

    print(str(tx) + " Textzeilen")                
    sizePerm = len(perm)
    print(str(sizePerm) + " Permzahlen")        
  

def callback(entry):    # universelle Ausgabe, als temporäre Debugfunktion
    print_filename()

Beim Klick auf ein Entry der Combobox wird 'print_filename' gerufen.

Wenn man die beiden einkommentierten print's entkommentiert, sieht man genau, was abläuft.

Ansonsten erscheinen nur 4 Meldungen in der Console:

- Dateiname

- x Permlines gefunden

- y Textzeilen

- x-y Permzahlen

 

Das Verfahren klappt auch für Wiesbaden-Perms.

Ich habe 389 Wiebaden-Perms von 2017. Da sehen die Kopfzeilen so aus (Beispiel):

TB1R-2017-01-04
 N  Z  R
 2        
       7  
    0     
22        
       1  
24        
      30  
...
...

Die Combobox zeigt die Dateinamen an und jeder Klick auf ein Entry füllt die int-Liste Perm[].

Jetzt brauchen wir die Klassen COUP und PERM. Die kann man einfach im try-Block bedienen.

Da habe ich erstmal eine Menge zu 'studieren'.

 

Viel Mühe mit Python!

Albert

Link zum Beitrag
Auf anderen Seiten teilen
vor 8 Stunden schrieb wiensschlechtester:

Somit hat die Roulettegeschichte noch einen positiven Lerneffekt. Vor langer Zeit steigerte ich z.B. damit meine Excel-Kenntnisse welche ich auch beruflich gut einsetzen konnte.

 

Das ist durchaus Sinn der Sache, denn wenn man nicht im Roulette gewinnt, sollte man wenigstens einen gut bezahlten Job haben.

Und soweit ich gehört habe, werden fähige Programmierer immer gesucht, zur Zeit besonders für Python.

 

Auch wenn ich keinen Job suchen muss, der mir Spass macht, lerne ich trotzdem gern dazu.

 

vor 8 Stunden schrieb wiensschlechtester:

Wir haben mehrere Coups - eh klar. Für jeden einzelnen Coup müssen wir die gefallenen Chancen bestimmen, sowie die Prognosen und Treffer/Nichttreffer bestimmen. Wenn man schon mit Klassen anfing...

 

Ich denke, Klassen sind kein Selbstzweck.

Man muss sich immer vorstellen, was man da tut.

 

Nehmen wir mal eine Zahlenkolonne, namens Perm, so müssen wir vorläufig nicht mehr damit tun,

als sie zu memorieren, bzw sie zu speichern.

 

Eine Prognosen für jede historische Zahlenreihe ist praktisch wertlos, es sei denn,

man will seine Prognosefähigkeit überprüfen.

 

Ich kann zur Zeit noch nicht mit Fachwissen darüber aufwarten, aber Python kennt sogenannte Generatoren.

Das sind Berechnungsvorschriften, die erst dann ausgeführt werden, wenn man die Ergebnisse tatsächlich sehen will.

Vorher existiert nur die Vorschrift, wie man zu dem Ergebnis kömmen würde.

Das ist ein massiver Optimierungsschritt, weil keine unverlangten Ergebnisse erzeugt werden müssen.

 

Das gleiche gilt auch für Chancenauswertungen, man muss sie nicht vorhalten, wenn man sie nicht begucken will.

Das erspart nebenbei auch Unsummen von Speicher, weil nur das berechnet wird, was man wissen will.

Danach kann es sogar gleich wieder der Garbagecollection zum Opfer fallen,

weil man inzwischen Ergebnisse von Ergebnissen gespeichert hat.

 

vor 8 Stunden schrieb wiensschlechtester:

(mein Python-Notizbuch füllt sich langsam)

 

Bitte versuche nicht, zu stramm zu lernen, mache Dir lieber mehr Gedanken darüber, wie das alles funktioniert.

Also stelle Dir einen winzigen Kern der Sprache vor, der durch reine Textdateien (in der Regel) immer mehr dazu lernt.

Das geschieht durch die Aufnahme von neuen Funktionen(Module etc), die erstmal gar nichts tun, bis man sie aufruft.

 

Ruft man sie gar nicht auf, haben sie zwar etwas Speicherplatz beansprucht, aber kaum Rechenzeit.

 

Stelle Dir eine Funktion vor, die eine Milliarde Zufallszahlen in eine Liste schreibt.

Das kostet eine Menge Zeit und Speicher, vielleicht mehr Speicher, als Dein Rechner hat.

Greifst Du nun nur einmal auf die erste Million Zahlen zu, brauchen 99,9% Deiner Milliarde gar nicht erzeugt werden.

Das spart ganz gewaltigt Speicher und Rechenkapazität.

 

Nur mal so als neue Anregung,

sich mit Generatoren in Python zu beschäftigen.

 

 

Viel Spass mit Python

wünscht Euch Ego

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 4 Stunden schrieb Dr. Manque:

Heute habe ich mich stundenlang mit .isdigit(), .lstrip() und .isalnum() herumgeärgert.

Ich wollte beim Thema "Permanenz extrahieren" ohne 'if re.match(parsePermFile[status],lines[x]):' auskommen (verzeih mir!).

 

 

Hallo Albert,

 

ich habe kein Problem damit, wenn Du Regular Expressions erstmal weglassen willst.

Das geht in Python ohne weiteres.

 

Deinen Ärger kann ich auch nachvollziehen, weil Du es gewohnt bist, Funktionen einen Parameter zu übergeben.

Das machst Du in Python zwar auch, aber mit leeren Klammern.

 

WTF???

 

Der Defaultparameter ist (self). Dadurch erklärt sich so Einiges.

Und die Methode (aka Funktion) ist ein Teil der Datenstruktur, mit der Du gerade arbeitest.

 

Ohne es jetzt ausprobiert zu haben, würde ich einfach mal hinschreiben:

"   \t  Hallo\tAlbert!!     \n".strip()

ergibt "Hallo(TAB)Albert!!"

 

Ich kann mich irren, aber schon ein hingeschriebener String hat alle Methoden eines Strings geerbt,

die man mit ".methode()" sofort anwenden kann.

 

vor 5 Stunden schrieb Dr. Manque:

Am Schluss hat es geklappt. (Und es war im Grunde auch wieder ganz einfach.)

 

Nicht locker lassen bitte, es wird sich auszahlen, wenn Du dranbleibst!

 

vor 5 Stunden schrieb Dr. Manque:

Ich habe 389 Wiebaden-Perms von 2017. Da sehen die Kopfzeilen so aus (Beispiel):

 

Ja, man kann mit sehr wenig Code filetierte Permanzenzdateien einlesen.

Mich hat es auch gewundert, dass meine Methode nicht in der Statistik gewütet hat,

die sich der Perm jedem Tag angeschlossen hat.

 

Man hat dann halt keine Rahmendaten zu den Zahlen.

 

vor 5 Stunden schrieb Dr. Manque:

Jetzt brauchen wir die Klassen COUP und PERM. Die kann man einfach im try-Block bedienen.

Da habe ich erstmal eine Menge zu 'studieren'.

 

Je länger ich darüber nachdenke, desto weniger bin ich davon überzeugt, dass wir eine Klasse für Einzelcoups brauchen.

Selbst bei der Klasse Perm bin ich mir nun nicht mehr sicher..

 

Genügt es nicht zu wissen, wo eine Perm gespeichert ist und wie man sie (ratzfatz) einliest?

Ebenso ist es dann überflüssig vorzuhalten, welche Zahlen rot oder schwarz sind (etc), wenn man sie nicht abfragt.

 

Wenn man Rechenschritte wegoptimieren kann, sollte man das tun.

Und das scheint mir in hohem Masse pythonisch zu sein.

 

 

Ich bin noch sehr am Anfang

und wünsche Euch auch viel Spass

mit Python,

Ego

 

 

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 10 Stunden schrieb Egoist:

 

Hallo Albert,

 

ich habe kein Problem damit, wenn Du Regular Expressions erstmal weglassen willst.

Das geht in Python ohne weiteres.

 

Deinen Ärger kann ich auch nachvollziehen, weil Du es gewohnt bist, Funktionen einen Parameter zu übergeben.

Das machst Du in Python zwar auch, aber mit leeren Klammern.

 

WTF???

 

Nimm "Ärger" nicht wörtlich.

Python wirkt halt hinterfotzig, weil so vieles implizit angelegt ist.

Wie hier die Klassen, Methoden, Attribute lokal/global zusammenspielen, das habe ich überhaupt noch nicht geschnallt.

 

vor 10 Stunden schrieb Egoist:

Der Defaultparameter ist (self). Dadurch erklärt sich so Einiges.

Und die Methode (aka Funktion) ist ein Teil der Datenstruktur, mit der Du gerade arbeitest.

 

Mir erklärt sich da noch nüscht, wird hoffentlich noch kommen.

 

vor 10 Stunden schrieb Egoist:

Nicht locker lassen bitte, es wird sich auszahlen, wenn Du dranbleibst!

 

Ich bleib' ja dran, schon deinetwegen. Endlich ein Partner für's Rouletteprogrammieren!

Nur noch lernende Programme will ich machen.

Die beiden VBA-Programme "ECS-Learn" und "TVS-Learn", die mit einfachen skalierbaren Lerntabellen arbeiten, sind ermutigend.

Es ist spannend, ob es mit Neuronalen Netzen noch besser geht. Das ist doch unser gemeinsames Ziel!!!?

 

vor 10 Stunden schrieb Egoist:

 

Je länger ich darüber nachdenke, desto weniger bin ich davon überzeugt, dass wir eine Klasse für Einzelcoups brauchen.

 

Unter VBA verwende ich pro Coup eine Struktur, in der die Chancenarten registriert sind, die zu der Coup-Plein gehören, also R oder S, 1. oder 2. Dtz, xte TVS u.s.w.

Das war immer nützlich, obwohl ein paar simple Zuordnungen zu viel laufen.

 

So könnte man eine Coup-Klasse verwenden, um dort die Chancenarten-Attribute unterzubringen.

Die Methoden pro Coup wären dann die Satzanalysen für den nächsten Coup und die Abrechnung der gefallenen Zahl.

Unter VBA habe ich das immer in einer Subroutine "CoupMain" zusammengefasst.

 

Doch, wir machen eine Coup-Klasse!

 

Man könnte auch dynamisch einfach auf die Listen in Deiner Klasse "Roulette-franz." zugreifen. (- müsste noch umbenannt werden -).

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']

Ich habe dieses Teil als 'roullib00.py' gespeichert, aber der import-Befehl im Testmodul sieht es nicht:

 

540269806_importroullib00.gif.755edd425d50b4c848f595e4a51014d3.gif

 

Da muss irgendwo eine Systemvariable gestellt werden. Weißt Du, wo und welche?

 

"Selbst bei der Klasse Perm bin ich mir nun nicht mehr sicher.."

 

Man hat ja immer nur eine Perm am Wickel.

Ein Perm-Klasse hätte die Liste der Coup-Instanzen als Attribut.

Als Methoden kämen Perm speichern, Perm laden, Perm löschen, Permtest und Pooltest  in Frage.

 

Wenn die Coup-Klasse geklärt ist, kann ich mit der Codierung des ersten Systems anfangen.

Egon, Du bist doch sicherlich in Deiner PyCharm-Umgebung auch so weit?

Schade, dass Du nicht Anaconda/Spyder benutzt. Der Spyder-Editor ist wirklich gut.

 

Python macht Arbeit!

Albert

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 6 Stunden schrieb Dr. Manque:

Ich habe dieses Teil als 'roullib00.py' gespeichert, aber der import-Befehl im Testmodul sieht es nicht:

 

 

Hallo Albert,

 

wenn Du das im gleichen Verzeichnis gespeichert hast, wie Deine aufrufende *.py sollte es gefunden werden.

Und wenn Du meinen Namenvorschlag genau so umgesetzt hast, wie ich angeregt hatte,

heisst die Datei "roulib00.py", also nur mit einem L.

 

Rest folgt später.

 

 

Gruss vom Ego

Link zum Beitrag
Auf anderen Seiten teilen
vor einer Stunde schrieb Egoist:

 

Hallo Albert,

 

wenn Du das im gleichen Verzeichnis gespeichert hast, wie Deine aufrufende *.py sollte es gefunden werden.

Und wenn Du meinen Namenvorschlag genau so umgesetzt hast, wie ich angeregt hatte,

heisst die Datei "roulib00.py", also nur mit einem L.

 

Rest folgt später.

 

 

Gruss vom Ego

 

Ja, es ist im gleichen Verzeichnis gespeichert, aber der Fehler kommt trotzdem.

Ob der Name des  py-files 1 oder 2 oder 7 l hat, das ist völlig egal, denn es ist ja alles auf meiner Kiste.

 

Ich habe schon reichlich Dr. Google befragt.

a) Das eigene Verzeichnis muss in die PYTHONPATH-Variable mit hinein. Aber wie???

b) Temporär kann man ganz oben im Testmodul schreiben:

     import sys

     sys.path.append("D:\Python"), wenn D:\Python das eigene Verzeichnis ist.

    Geholfen hat es nicht (bisher)!

 

Albert

 

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 47 Minuten schrieb Dr. Manque:

Ja, es ist im gleichen Verzeichnis gespeichert, aber der Fehler kommt trotzdem. 

Ob der Name des  py-files 1 oder 2 oder 7 l hat, das ist völlig egal, denn es ist ja alles auf meiner Kiste.

 

Sorry, mir war nur aufgefallen, dass Deine Datei 2 L hatte und meine nur 1.

Natürlich ist es Wurst wieviele Du benutzt, Hauptsache Du versuchst dann auch die Datei mit der richtigen Anzahl zu importieren.

 

Anaconda.navigator und Spyder habe ich hier leider zerschossen, weil ich ältere Module installieren liess.

Dafür geht KIVY nun...

Ich hatte halt noch nicht kapiert, wie das mit den virtuellen Arbeitsumgebungen so funzt.

 

Welche Pfade Deine aktuelle (evtl auch virtuelle) Umgebung benutzt, kann ich nicht sagen,

aber es gibt auch noch Foren mit Pythoncracks, da kann man sicher nachfragen.

 

Vielleicht wissen Wiener oder novice mehr, die haben auch Deine IDE.

Was sagt denn Spyder zu seiner eigenen Fehlermeldung?

 

 

bearbeitet von Egoist
Link zum Beitrag
Auf anderen Seiten teilen
vor 15 Stunden schrieb Egoist:

Nachtrag:

 

Es war nur eine Frage an youtube entfernt: "Anaconda spyder path to module"

https://www.youtube.com/watch?v=A7E18apPQJs

 

Ich hoffe Du kannst folgen.

Hallo Ego,

 

danke für den Link, kann folgen, aber das Problem hat sich inzwischen erledigt.

Habe erst jetzt gesehen, dass ein eigenes Verzeichnis in sys.path registriert ist.

Das ist wohl bei der Anaconda-Installation da hinein gekommen.

Ich musste also nur meine *.py-Moduln dahin kopieren und jetzt geht's.

    x = 0
    tx = 0
    perm = []

    for each in lines:
        ti = lines[x].rstrip()  # Escapes und Blanks herausnehmen
        
        try:
            i = int(ti) 
            print(i)
            perm.append(i) 
            print(roullib00.ChancenArten.c12_tvp[i])           
            print(roullib00.ChancenArten.ec_RS[i])                   
            
        except:
            tx += 1
#            print("Textzeile:" + ti)
            
        x += 1

Die Klasse "Roulette_franz"  in roullib00 habe ich in "ChancenArten" umbenannt.

Die beiden prints hinter try: haben mir gezeigt, dass der Zugriff auf die von Dir definierten Listen hinhaut.

 

Nun kann die Klasse 'Coup' kommen.

 

Gruß!

Albert

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 6 Stunden schrieb Dr. Manque:

Habe erst jetzt gesehen, dass ein eigenes Verzeichnis in sys.path registriert ist.

Das ist wohl bei der Anaconda-Installation da hinein gekommen.

Ich musste also nur meine *.py-Moduln dahin kopieren und jetzt geht's.

 

Hallo Herr Doktor,

 

wieder ein Problem erschlagen, welches uns nun nicht mehr ärgern kann. :)

 

vor 6 Stunden schrieb Dr. Manque:

Die beiden prints hinter try: haben mir gezeigt, dass der Zugriff auf die von Dir definierten Listen hinhaut.

 

So war das auch angedacht, allerdings benutzt Du Python noch etwas umständlich, der code:

            print(roullib00.ChancenArten.c12_tvp[i])           
            print(roullib00.ChancenArten.ec_RS[i])

liesse sich verschlanken, ausserdem hast Du das Modul und die Klasse umbenannt.

Das führt nun dazu, das meine Programme nicht mehr mit Deiner Library funktionieren und umgekehrt.

 

vor 7 Stunden schrieb Dr. Manque:

Die Klasse "Roulette_franz"  in roullib00 habe ich in "ChancenArten" umbenannt.

 

Vielleicht hattest Du einen triftigen Grund für diese Codegabelung, für eine gemeinsame Arbeit ist das aber nicht so empfehlenswert.

 

Ich kann Dir begründen, warum ich meine Klasse Roulette_franz() genannt habe:

  • In der ersten Liste (pl_Kessel) stehen alle Zahlen eines französischen Kessels im Uhrzeigersinn.
    man könnte sie einfach austauschen mit denen aus einem  amerikanischen Doppelzero-Kessel,
    oder mit jeder anderen Zahlenfolge.
  • Ausser der Rückreferenz in der 2. Liste (pl_Fach), die einmal aus pl_Kessel berechnet werden kann,
    können alle anderen Listen fast so bleiben, wie sie sind, man müsste nur ein 38.Fach anfügen mit der Doppelzero.
  • Die Klasse ist noch nicht fertig, weil ihr in Zukunft noch weitere Methoden beigebracht werden sollen.
    Dann wäre ein Klassenname "ChancenArten" etwas irreführend.
    Ich weiss nicht, ob Du die Methode print_Segment schon in Deinem Modul mit drin hast.
    Falls ja, hättest Du den undeutlich sprechenden Aufruf roullib.ChancenArten.print_Segment(...).
     

Es spricht überhaupt nichts dagegen, wenn Du Deinen Bezeichner ChancenArten in Deinem Code benutzen möchtest.

Das geht mit meinem Modul auch.

import roulib00 as r				# Der (sperrige) Name des Moduls darf angepasst werden

ChancenArten = r.Roulette_franz()   # Konstruktor, der eine Instanz mit frei wählbarem Namen erzeugt.

Auf das Modul musst Du dann auch nicht mehr verweisen, weil in Deiner Instanz alle Tabellen und Methoden vorliegen.

print(ChancenArten.ec_RS[3])  # sollte genügen um eine 1 für Rot auszuwerfen

print(ChancenArten.format_Farbe[4])  # druckt Dir eine 4 auf schwarzem Grund

 

Es ist von mir nur gemutmasst, aber das sollte dann auch schneller ablaufen, weil es roulib.Roulette_franz.ec_RS[x],

bzw roullib.ChancenArten.ec_RS[x] gar nicht im Speicher gibt.

Die Listen in der Klassendefinition sind nur Kochrezepte, die besagen, wie man sowas zubereitet.

In der angelegten Instanz sind alle Listen aber schon fein säuberlich angelegt worden.

 

vor 8 Stunden schrieb Dr. Manque:

Nun kann die Klasse 'Coup' kommen.

 

Du hast in den nächsten Wochen freie Bahn, weil ich bis zum Ende der übernächsten Woche deutlich weniger Zeit haben werde.

Das heisst sicher nicht, ich würde nicht täglich mit Interesse hier reinschauen und auch meinen Senf abgeben,

aber zum Programmieren werde ich wohl nicht genug Dampf auf der Leitung übrig haben.

 

Du kannst Klassen auch in Deinem Programmcode definieren, das muss nicht sofort in das universelle Modul.

Ebenfalls kannst Du Deine eigenen Module basteln, die Deiner persönlichen Arbeitsweise behilflich sind.

Wiederkehrende Funktionen und Datenstrukturen werden sich sicher bald herauskristallisieren.

 

 

Viel Spass mit Python

wünscht Ego

Link zum Beitrag
Auf anderen Seiten teilen
Am 1.8.2018 um 01:21 schrieb Egoist:

 

Hallo Herr Doktor,

 

wieder ein Problem erschlagen, welches uns nun nicht mehr ärgern kann. :)

 

 

So war das auch angedacht, allerdings benutzt Du Python noch etwas umständlich, der code:

            print(roullib00.ChancenArten.c12_tvp[i])           
            print(roullib00.ChancenArten.ec_RS[i])

liesse sich verschlanken, ausserdem hast Du das Modul und die Klasse umbenannt.

Das führt nun dazu, das meine Programme nicht mehr mit Deiner Library funktionieren und umgekehrt.

 

 

Vielleicht hattest Du einen triftigen Grund für diese Codegabelung, für eine gemeinsame Arbeit ist das aber nicht so empfehlenswert.

 

Ich kann Dir begründen, warum ich meine Klasse Roulette_franz() genannt habe:

  • In der ersten Liste (pl_Kessel) stehen alle Zahlen eines französischen Kessels im Uhrzeigersinn.
    man könnte sie einfach austauschen mit denen aus einem  amerikanischen Doppelzero-Kessel,
    oder mit jeder anderen Zahlenfolge.
  • Ausser der Rückreferenz in der 2. Liste (pl_Fach), die einmal aus pl_Kessel berechnet werden kann,
    können alle anderen Listen fast so bleiben, wie sie sind, man müsste nur ein 38.Fach anfügen mit der Doppelzero.
  • Die Klasse ist noch nicht fertig, weil ihr in Zukunft noch weitere Methoden beigebracht werden sollen.
    Dann wäre ein Klassenname "ChancenArten" etwas irreführend.
    Ich weiss nicht, ob Du die Methode print_Segment schon in Deinem Modul mit drin hast.
    Falls ja, hättest Du den undeutlich sprechenden Aufruf roullib.ChancenArten.print_Segment(...).
     

Es spricht überhaupt nichts dagegen, wenn Du Deinen Bezeichner ChancenArten in Deinem Code benutzen möchtest.

Das geht mit meinem Modul auch.

import roulib00 as r				# Der (sperrige) Name des Moduls darf angepasst werden

ChancenArten = r.Roulette_franz()   # Konstruktor, der eine Instanz mit frei wählbarem Namen erzeugt.

Auf das Modul musst Du dann auch nicht mehr verweisen, weil in Deiner Instanz alle Tabellen und Methoden vorliegen.

 

Hallo Ego,

Hallo Ego

 

Das Prinzip habe ich übernommen:

mit objekt as class zuerst ein Objekt anlegen und damit weiterarbeiten.

 

Ein paar Namensunterschiede stören die Zusammenarbeit nicht.

Abstimmen werden wir die Algorithmen. Wenn dabei einige Umbenennungen nötig sind, dann steigert das die Aufmerksamkeit

und verbessert die Kontrolle - nehme ich an.

 

Zitat

 

Du hast in den nächsten Wochen freie Bahn, weil ich bis zum Ende der übernächsten Woche deutlich weniger Zeit haben werde.

Das heisst sicher nicht, ich würde nicht täglich mit Interesse hier reinschauen und auch meinen Senf abgeben,

aber zum Programmieren werde ich wohl nicht genug Dampf auf der Leitung übrig haben.

 

Ich bin auch ab morgen bis zum 15. Aug. ausgeknockt.

Wir fahren mit 2 Enkeln nach Dierhagen an die Ostsee.

 

Ich hatte eben ein langes Posting fertiggemacht.

Beim Abschicken wurde "FORBIDDEN" angezeigt.

 

Den 2. Teil konnte ich über Word retten.

Mal schauen, ob er sich separat posten lässt. 

Bis gleich!

Albert

 

Vor der Reise wollte ich noch eine Miniform der Klasse 'Coup' ausprobieren.

Hier ist sie:

 

class Coup:

    counter = 0

   

    def __init__(self):

        type(self).counter += 1

        pl_nr = 0

        ec_SR = 0

        ec_GU = 0

        ec_MP = 0

        dc_KO = 0

        dc_DU = 0

        c6_TVS = 0

        c12_TVP = 0

 

    @classmethod   

    def AnzahlCoups():

        return Coup.counter

 

    pass  

 

Die Initialisierung der Daten-Attribute ist wahrscheinlich gar nicht notwendig?

Bei der Instanziierung der Coup-Objekte wiederholt sich das jedesmal.

 

Nach dem bisherigen Stand wird mit der Liste Perm schon ein Vektor, eine eindimensionale Tabelle der gefallenen Zahlen erzeugt.

Das geschieht in der Methode "print_filename", die per callback() angesprochen wird, wenn man auf ein Combobox-Entry klickt.

 

Parallel dazu lasse ich nun mit 'couplist' eine Liste von Coup-Objekten erzeugen. Jedes Coup-Objekt enthält noch einmal die Plein-Nr. und die Attribute,

die zusätzlich für verschiedene Roulette-Simulationen gebraucht werden.

Bei der Benennung der Attribute möchte ich bei dem bleiben, woran ich gewöhnt bin, also RS, GU, MP, KO, DU.

 

Hier ist der erweiterte Code der Methode "print_filename":

def print_filename():
    fn = dirtext.get()
    fn += "\\"
    fn += combo_1.get()
    print(fn)
    
    file = open(fn)
    lines = file.readlines()
    print(str(len(lines)) + " Permlines gefunden.")
    file.close()  
        
    x = 0
    tx = 0
    perm = []
    couplist = []
 
    for each in lines:
        ti = lines[x].rstrip()  # Escapes und Blanks herausnehmen
        
        try:
            i = int(ti) 
#            print(i)
            perm.append(i) 
 
            cp = roul.Coup()  # eine neue Coup-Instanz
            # die Attribute aktualisieren
            cp.pl_nr = i
            cp.ec_SR = ChArten.ec_RS[i]
            cp.ec_GU = ChArten.ec_UG[i]
            cp.ec_MP = ChArten.ec_TH[i]   
            cp.dc_KO = ChArten.dc_col[i]
            cp.dc_DU = ChArten.dc_duz[i]
            cp.c6_TVS = ChArten.c6_tvs[i]
            cp.c12_TVP = ChArten.c12_tvp[i]  
            # ein paar Testausgaben
            print(str(cp.pl_nr) + "  " + str(cp.dc_DU) + "  " + str(cp.c6_TVS))            
            couplist.append(cp)                  
            
        except:
            tx += 1
#            print("Textzeile:" + ti)
            
        x += 1
 
    sizePerm = len(perm)  # Anzahl der Permzahlen
    # Anzeige der Textzeilen und Permzahlen in label6
    label6.configure(text=(str(tx) + " Textzeilen, " + str(sizePerm) + " Permzahlen"))
  
 
def callback(entry):    # universelle Ausgabe, als temporäre Debugfunktion
    print_filename()
   
    lastcoup = roul.Coup.counter
    print(str(lastcoup) + " Coup-Objekte angelegt")

 

bearbeitet von Dr. Manque
Ergänzung
Link zum Beitrag
Auf anderen Seiten teilen

Hallo Ego,

 

ich konnte das vorige Posting nicht zu Ende bringen.

Es kam immer eine Meldung "Access Forbidden".

 

Mal sehen, ob diese Ergänzung durchgeht.

 

Auch lange Perms sind unterhalb 1 sec. durchgelaufen.

Dieses GIF-Bild, zeigt eine Endabrechnung:

 

1360552707_Objekteangelegt.gif.5781b341fb070777f036d9db5414f5eb.gif

Die Testprint-Zeilen in der Console bestätigen, dass die coupliste richtig gefüllt wird - auch mit >1000 Coup-Objekten.

Die print-Zeilen zeigen die Plein-Nrn., ihre Dtz und TVS.

 

Die coupliste kann nun mit cp = coupliste[index] rauf und runter iteriert und so für irgendein Simulationsverfahren ausgewertet werden.

Für den Test gespeicherter Perms ist der Testrahmen fertig, wenn auch in der GUI noch Felder für Parameter, Satzanzeigen und Abrechnungen einzurichten sind.

 

Zuerst möchte ich das novice-Verfahren damit ausprobieren.

 

Albert

Link zum Beitrag
Auf anderen Seiten teilen
vor 6 Stunden schrieb Dr. Manque:

Auch lange Perms sind unterhalb 1 sec. durchgelaufen.

 

Hallo Albert,

 

es freut mich zu sehen, wie es Dich gepackt hat.

Und ja Python erledigt sowas im Handumdrehen.

 

vor 6 Stunden schrieb Dr. Manque:

Die coupliste kann nun mit cp = coupliste[index] rauf und runter iteriert und so für irgendein Simulationsverfahren ausgewertet werden.

 

Es ginge aber noch viel schneller und mit sehr viel weniger Speicherbedarf.

Warum ich das für wichtig erachte?

 

Ich hatte hier schon mit künstlichen Permanenzen im 3stelligen Millionenbereich hantiert,

da geht es nicht, dass man die (sehr leicht und sehr schnell) berechneten Zwischenergebnisse speichert.

 

Die Klasse Roulette_franz bietet alle Chancen virtuell an, wenn Du die Plein kennst, wirfst Du sie einfach dort hinein.

Heraus kommen alle Chancen, die mit dieser Plein getroffen wurden.

 

Letztlich ist es egal, ob man die Ergebnisse aus dem Speicher holt, oder frisch berechnet.

Du denkst noch zu sehr in Excel, denn da muss man jedes noch so kleines Zwischenergebnis festhalten.

Daher ist diese MS-Möhre ja so schwerfällig.

 

Etwas anderes ist es mit Auswertungsdaten, die hunderte, tausende oder Millionen Coups umfassen.

Sowas muss man speichern, weil eine Neuberechnung unzumutbar ist.

Also, wenn man zB wissen will, vieviele Treffer auf Rot in den letzten 37 Coups kamen,

erzeugt man über alle Coups(evtl Millionen)  eine Liste der roten Treffer.

Die passen vielleicht gerade noch in den Speicher.

Dann hampelt man die Liste durch und speichert die Treffer der ersten 37 Coups auf Rot in Element[0].

In Element[1] kommt dann der Treffer auf Rot in Coup[38] dazu, abzüglich eines eventuellen Treffers

aus Coup[0].

 

Danach kann man die Liste aller roten Treffer wieder vergessen, denn man hat nun diese Auswertung gesichert.

 

vor 8 Stunden schrieb Dr. Manque:

Ein paar Namensunterschiede stören die Zusammenarbeit nicht.

Abstimmen werden wir die Algorithmen. Wenn dabei einige Umbenennungen nötig sind, dann steigert das die Aufmerksamkeit

und verbessert die Kontrolle - nehme ich an.

 

Babylon lässt grüssen, aber mir soll es recht sein.

 

 

Gruss vom Ego

 

(Viel Spass an der pisswarmen Ostsee, ich wohne selbst dort dicht bei)

 

Link zum Beitrag
Auf anderen Seiten teilen
  • 3 weeks later...

Hallo Leute,

 

nach der Vertilgung einer Pulle trockenen Rotweines kam mir gerade eine Schnapsidee in den Sinn.

Wenn durchschnittlich (zu 50%++)  nach 7-8 Coups ein Doppler erscheinen soll,

wäre es doch sinnvoll, da mal einzuhaken.

 

Kamen in den letzten x Coups im Schnitt weniger F2 vor, als1/8 pro coup,

dann mangelte es dem Zufall kürzlich an Favoriten.

 

Da sollte sich was draus basteln lassen...

Ups... Akku ist alle

 

 

Gruss vom Ego

bearbeitet von Egoist
Hab ja noch andere Rechner ;)
Link zum Beitrag
Auf anderen Seiten teilen

Leider nein, denn es wurden mehr als 20 Singles hintereinander beobachtet. Wenn Du also dann 20 Singles setzt ist Dir das Risiko schon klar.

Analog anwendbar für alle niedrigeren Anzahlen von Singles.

 

Es ist folgendes schon schwierig genug zu spielen:

In 13 Coups sollten 2 F2 auftreten. Spielt man von anbeginn alle gefallenen Zahlen nach bis man 12 Zahlen nachspielt, ist der Platzer so groß, daß die fast 92%ige Trefferchance nicht ausreicht.

Link zum Beitrag
Auf anderen Seiten teilen
vor 2 Stunden schrieb Ropro:

Leider nein, denn es wurden mehr als 20 Singles hintereinander beobachtet. Wenn Du also dann 20 Singles setzt ist Dir das Risiko schon klar.

Analog anwendbar für alle niedrigeren Anzahlen von Singles.

 

Es ist folgendes schon schwierig genug zu spielen:

In 13 Coups sollten 2 F2 auftreten. Spielt man von anbeginn alle gefallenen Zahlen nach bis man 12 Zahlen nachspielt, ist der Platzer so groß, daß die fast 92%ige Trefferchance nicht ausreicht.

Hallo Ropro,

habe ich mir doch gedacht, dass Du darauf anspringst -:)

In diese Richtung war ich auch schon unterwegs mit der selben Schlussfolgerung.

ABER: hast Du schon einmal angedacht, oder gar nachgeschaut, wie es aussieht, wenn Du nicht von  Anfang an nachsetzt (also 1+2+3+4 usw, sondern erst ab dem 8. oder begrenzt um den Erwartungswert von 9 herum, also z.B. vom 6. bis 12 (3 vorher und 3 hinterher)?

LG

FavRad

 

Link zum Beitrag
Auf anderen Seiten teilen
vor 5 Stunden schrieb FavRad:

Hallo Ropro,

habe ich mir doch gedacht, dass Du darauf anspringst -:)

In diese Richtung war ich auch schon unterwegs mit der selben Schlussfolgerung.

ABER: hast Du schon einmal angedacht, oder gar nachgeschaut, wie es aussieht, wenn Du nicht von  Anfang an nachsetzt (also 1+2+3+4 usw, sondern erst ab dem 8. oder begrenzt um den Erwartungswert von 9 herum, also z.B. vom 6. bis 12 (3 vorher und 3 hinterher)?

LG

FavRad

 

Natürlich!

Hier kannst Du die Basisdaten dazu betrachten:

 

https://www.roulette-forum.de/topic/17987-entwicklung-der-treffer-innerhalb-25-coups/?do=findComment&comment=350323

bearbeitet von Ropro
Link zum Beitrag
Auf anderen Seiten teilen

Wie ist deine Meinung dazu?

Du kannst jetzt schreiben und dich später registrieren. Bereits registrierter Teilnehmer? Dann melde dich jetzt an, um einen Kommentar zu schreiben.
Hinweis: Dein Beitrag wird nicht sofort sichtbar sein.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung jetzt entfernen

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

×
×
  • Neu erstellen...