Anzahl von sich ändernden Werten feststellen?

[blubber]

Hallo,

ich sitze hier gerade vor einer Aufgabenstellung und mir fehlt noch ein anständiger Lösungsansatz, aber vielleicht hat ja hier jemand eine Idee!?

Und zwar habe ich eine gewöhnliche Variable (von extern), nennen wir sich einfach mal "variableX".
Diese Variable enthält mindestens einen Integerwert (z.B. 100). Dieser Wert entspricht einem Fehlercode, aber das nur nebenbei. Nun das Problem: Sind mehrere Fehler aufgetreten, dann werden die Fehlercodes zyklisch durchlaufen.
Beispiel: Es gibt zwei Fehler:
Fehler 1 = Fehlercode 100
Fehler 2 = Fehlercode 200

Dann ändert sich jede Sekunde der Wert der Variablen, also
100 (1. Sekunde)
200 (2. Sekunde)
100 (3. Sekunde)
200 (4. Sekunde)
usw.
usw.

Ich sollte nun zum einen feststellen, wieviele Werte gerade zyklisch durchlaufen werden (also wieviel Fehlercodes anliegen), und am besten auch noch welche das sind....
Muss wie gesagt kein fertiger Code sein, ein Lösungsansatz würde mir schon weiterhelfen......wobei ich über einen Code net böse wäre

Gruß

[BlackJack]

Würde es nicht reichen, wenn Du mit einer Liste beginnst, die den ersten Code enthält und dann solange weitere hinzufügst, bis wieder der erste ausgelesen wurde? Dann müsstest Du ja einen Zyklus durchlaufen haben.

Also ganz grob so:

Code: Alles auswählen

def get_error_codes():
    result = [get_current_error_code()]
    while True:
        error_code = get_current_error_code()
        if error_code == result[0]:
            break
        result.append(error_code)
    return result

[blubber]

Danke für die Antwort, hat mir sehr geholfen. Hab es jedoch noch ein wenig erweitern müssen, da ich ein Punkt vergessen hatte: Die Fehlernummern werden nach Priorität angezeigt, sprich, wenn es 3 Fehler gibt, und 2 haben hohe Priorität, dann kann es sein, dass der Zyklus so aussieht:

Fehler 100
Fehler 200
Fehler 100
Fehler 200
Fehler 300
usw usw.

Hier mal mein Code, mir kommt es noch etwas "kompliziert" vor, also ich bin mir nicht sicher, ob man das vereinfachen kann. Falls ja, wäre ich für Vorschläge sehr dankbar!!

Code: Alles auswählen

def fehlertest():
    x = 0                                            #Variable für äußere Schleife
    
    liste = [get_fehler_nummer()]                    #FehlerNr einlesen
    fehler_anzahl = 1                                #1 FehlerNr vorhanden (Minimum)
    y = fehler_anzahl                                #y = Variable für innere Schleife
    
    while x < 100:
        
        fehlercode = get_fehler_nummer()                   #FehlerNr einlesen
        fehler_vorhanden = 0                               #Momentan keine FehlerNr in Liste erkannt
        
        while y > 0:
            if liste[y-1] == fehlercode:                   #Wenn FehlerNr in Liste vorhanden,
                fehler_vorhanden = 1                       #dann setzte Variable auf 1
            y = y - 1
        
                
        
        if fehler_vorhanden == 0:                          #Wenn FehlerNr nicht (Variable = 0) in Liste,
            liste.append(fehlercode)                       #dann füge FehlerNr zur Liste hinzu
            fehler_anzahl = fehler_anzahl + 1              #und inkrementiere Fehleranzahl
        
        y = fehler_anzahl                                  #Setze y auf Wert von Fehleranzahl für Schleife
        x = x + 1
        time.sleep(0.01)
    
    print liste                                            #Fehlerliste anzeigen

[BlackJack]

Ich denke trotzdem das mein Ansatz ausreicht. Nur wenn "Fehler 300" schon vor oder nach der ersten Zeile bei den Fehlern aufgetreten ist, müsste man es komplizierter machen. Andernfalls kann man immer sagen, dass man damit leben muss, dass ein Fehler zu spät für die Erkennung auftrat. Dein Ansatz macht ja nichts anderes als 100 mal hintereinander auf Fehler zu prüfen. Wenn beim 101. Durchlauf eine neue Fehlernummer hinzukommen würde, hättest Du die auch nicht erfasst. Das liegt einfach in der Natur der Sache.

Und Deine Vermutung Dein Code wäre zu kompliziert, trifft zu. Die äussere ``while``-Schleife wird 100 mal durchlaufen. Es gibt also keinen Grund die über den ganzen Quelltext zu verteilen ─ vor der Schleife die Initialisierung von `x` dann die Schleife und in der Schleife das Erhöhen von `x`. Das lässt sich ganz einfach durch eine ``for``-Schleife ersetzen.

Dann `y` und `fehler_anzahl`: Listen kennen ihre eigene Länge, die kann man mit `len()` abfragen, man braucht also nicht parallel selber Buch darüber zu führen. Und ob ein Element in einer Liste enthalten ist, kann man mit dem ``in``-Operator überprüfen, dafür brauchts keine komplizierte ``while``-Schleife. Ausserdem erkennst Du keine Zyklen sondern überprüfst immer nur ob der Fehler schon einmal gesichtet wurde, dass heisst Du kannst auch mit der leeren Liste beginnen.

Da würde also letztendlich folgendes übrig bleiben:

Code: Alles auswählen

def fehlertest():
    result = list()
    
    for dummy in xrange(100):
        error_code = get_fehler_nummer()
        if error_code not in result:
            result.append(error_code)
        time.sleep(0.01)
    
    return result

Wenn man die Liste durch ein `set()` ersetzt, wird es noch ein bisschen kürzer:

Code: Alles auswählen

def fehlertest():
    result = set()
    
    for dummy in xrange(100):
        result.add(get_fehler_nummer())
        time.sleep(0.01)
    
    return result

[blubber]

*schluchz*
Das ist jetzt aber ganz schön ernüchternd. Ich verrate lieber nicht, wie lange ich mir den Kopf über meinen Code zerbrochen habe...und nun ist das alles mit einem Viertel zu realisieren. Naja ok, werde natürlich Deinen Code übernehmen, vielen Dank für die Hilfe!

Gruß