Eine Art RS-FlipFlop

[Sirius3]

@Alfons Mittelmeyer: wenn es um kompliziertere Sachen geht, reicht doch ein Index in eine Liste nicht mehr aus. Dann muß man mit if-else arbeiten oder Funktionen in einer Liste. Dass man sich selbst eine verkettete Liste programmiert, ist heutzutage und dazu noch in Python eher unüblich, da man dafür schon fertige Konstrukte hat. Wie das geht, hat kbr ja schon gezeigt.

[Alfons Mittelmeyer]

@Alfons Mittelmeyer: wenn es um kompliziertere Sachen geht, reicht doch ein Index in eine Liste nicht mehr aus.

Es geht hier nicht um eine Patentlösung auch für die kompliziertesten Sachen. Es geht um einen Ablauf, bei dem sich in einigen Details das Verhalten ändert.

Dann muß man mit if-else arbeiten oder Funktionen in einer Liste.

Dass man um if else bei einem Programm nicht ganz herum kommt ist klar, aber zur Unterscheidung des Verhaltens braucht man dann kein if else, wenn man auf ein Objekt, welches das geänderte Verhalten beschreibt, umschaltet, sei es durch Ändern einer Referenz oder eines Indexes

Dass man sich selbst eine verkettete Liste programmiert, ist heutzutage und dazu noch in Python eher unüblich, da man dafür schon fertige Konstrukte hat. Wie das geht, hat kbr ja schon gezeigt.

Es geht hier nicht um die Programmierung einer verketteten Liste, nur wenn man sowieso schon Objekte mit diversen Eigenschaften hat, warum soll man dann noch extra ein weiteres Konstrukt für eine Referenz auf das nächste Element benützen, wenn man das ganz einfach in die Objekte eintragen kann und sich so Zusätzliches spart.

Etwas Anderes wären natürlich verkettete Listen, in die man nachträglich noch etwas einfügt oder herauslöscht. Klar, dass man sich so etwas nicht selber nochmals programmiert. Python hat da schon solche Konstrukte.

[Sirius3]

@Alfons Mittelmeyer: wenn man die »einigen Details« nicht genau kennt, kann man kein Patentrezept geben.

... wenn man das ganz einfach in die Objekte eintragen kann und sich so Zusätzliches spart.

Genau das ist ja das Problem bei Deinem Vorgehen. Du sparst nicht, sondern Du packst was zusätzlich in ein Objekt, das da nichts verloren hat. Ein Objekt sollte eine Sache gut machen, und nicht noch eine zweite schlecht. Wie man mit einer Liste umgeht weiß jeder, wie das Attribut für die Verkettung heißt, muß man immer wieder nachschauen. Nächster Grund, warum man keine Objekte um eine Verkettung erweitert: so kann das Objekt nur in einer Liste vorkommen.

So und jetzt fangen wir ganz primitiv mit Zählen an: __init__ braucht ein zusätzliches Argument und ein zusätzliches Attribut, beim Erzeugen brauch ich ein Argument mehr und ich muß mir das erste Objekt merken, um den Ring zu schließen. Und dann mußt Du das ganze noch von Hinten her aufbauen!

Alternativ:

Code: Alles auswählen

from itertools import cycle
import time
 
class AnimationProperty():
    def __init__(self, text):
        self.text = text
        # evtl. weitere Eigenschaften

properties = cycle([
    AnimationProperty("Text1"),
    AnimationProperty("Text2"),
])

max_breite = 10
breite = 0
property = next(properties)
while True:
    #draw.rectangle(hoehe, breite)
    time.sleep(1)
    breite += 5
    if breite >= max_breite:        
        property = next(properties)
        breite = 0
 
    print(property.text)

So muß das Objekt nichts mehr davon wissen, wie es in irgendeine übergeordnete Struktur eingebunden wird, ist schön schlank (hier so schlank, dass man es gleich weglassen kann), Zuständigkeiten sind klar getrennt.

Der Aufwand ist auf keinen Fall größer als bei Deiner Art zu Programmieren, die Vorteile sind aber hoffentlich auch Dir klar geworden.

[BlackJack]

@Alfons Mittelmeyer: Wenn man sowieso schon ein Objekt hat, kann man da ja gleich noch andere Funktionalität mit reinbasteln statt für die andere Funktionalität ein eigenes Objekt zu schreiben klingt nach einem schönen Rezept unübersichtliche Programme zu schreiben und das selbe an mehreren Stellen immer wieder neu zu erfinden. Es gibt doch bereits `itertools.cycle()`. Das ist einmal eine Lösung für dieses Problem nicht irgendwo reingebastelt wo es nicht hingehört, sondern separat und wiederverwendbar.

[Alfons Mittelmeyer]

@BlackJack:

statt my_object = my_object.next_object soll ich also itertools nehmen.

was nehme ich aber dann für my_strasse = my_object.strasse

Gibt es dafür vielleicht ein Adressverwaltungstool, das man dafür nehmen soll?

Oder schreibt man besser:

my_object = my_object2 if my_object == my_object1 else my_object1

[Sirius3]

@Alfons Mittelmeyer: »my_xxx« schreibst man sowieso nicht, weil das my-Präfix gar nichts aussagt. Und wie ich schon geschrieben habe, sollte ein Objekt nichts über seine Einordnung in eine übergeordnete Datenstruktur wissen müssen. Was Du mit einer Straße machen sollst, wirst nur Du wissen.

[Alfons Mittelmeyer]

@Alfons Mittelmeyer: »my_xxx« schreibst man sowieso nicht, weil das my-Präfix gar nichts aussagt.

Es geht ja hier nicht um konkreten Code, sondern ein allgemeines Beispiel. Ist das jetzt besser?

x = z if x == y else y

Und wie ich schon geschrieben habe, sollte ein Objekt nichts über seine Einordnung in eine übergeordnete Datenstruktur wissen müssen

Ich wollte kar keine übergeordnete Datenstruktur haben. Und ein Objekt weiß sowieso nichts, denn es ist nicht intelligent. Oder ist ein zugeordnetes Attribut bereits Wissen?

Außerdem, warum soll jemand nicht seinen Nachfolger selbst bestimmen können. Muss das ein Höherer sein, der das bestimmt?
Außerdem, bestimmt das Objekt nicht seinen Nachfolger, der ist nur hier erfasst und warum soll man noch eine übergeordnete Datenstruktur haben? Oder eine Logik, die den Nachfolger ermittel?. Warum diesen nicht gleich vorgeben? Bzw. wenn man ihn vorgibt, warum dann extra in einer übergeordneten Datenstruktur?

[Sirius3]

@Alfons Mittelmeyer: warum sollte das jetzt besser sein, wenn es ›cycle‹ gibt? Natürlich ist ein Attribut Wissen, das ein Objekt hat. Aber ein Objekt sollte eben kein Wissen darüber haben, wie es verwendet wird. Das Kapseln ist ja gerade der Sinn von Objektorientierung. Du stellst die falschen Fragen. Warum sollte das Objekt etwas über ihren Nachfolger wissen? Das ist für die Aufgabe, die das Objekt erfüllen soll, nicht nötig.

[DeaD_EyE]

Der Titel des Themas zieht wahrscheinlich viele an, die wirklich ein Flipflop programmieren möchten.
Wie programmiert ihr ein FlipFlop in Python?

Hier mein Ansatz:

Code: Alles auswählen

class FlipFlop:
    def __init__(self, state=False):
        self.state = state
    def __bool__(self):
        return self.state
    def __int__(self):
        return 1 if self.state else 0
    def __index__(self):
        return int(self)
    def __lshift__(self, val):
        return int(self) << val
    def __repr__(self):
        return '{}(state={})'.format(self.__class__.__name__, self.state)

class SR(FlipFlop):
    """Rücksetzdominaz"""
    def __call__(self, in_set=None, in_reset=None):
        if in_reset:
            self.state = False
        elif in_set and not in_reset:
            self.state = True
        return self.state

class RS(FlipFlop):
    """Setzdominaz"""
    def __call__(self, in_set=None, in_reset=None):
        if in_set:
            self.state = True
        elif not in_set and in_reset:
            self.state = False
        return self.state

Gibt sicherlich bessere Ideen. GGf. das Thema splitten und das alte umbenennen.

[kbr]

Wie programmiert ihr ein FlipFlop in Python?

Angenommen state sei ein boolean:

Code: Alles auswählen

state = not state

[DeaD_EyE]

Ja, das wäre die Invertierung mit Zuweisung. Ich habs mit einer direkten Zuweisung gemacht.
Die Implementierung ist recht billig. Ich glaube, dass die Resultate auch richtig sind.
Jemand der den Code verwendet, sollte erstmal mit einer Wahrheitstabelle prüfen ob das überhaupt stimmt

Code: Alles auswählen

In [4]: flipflop1 = SR()
In [5]: flipflop1
Out[5]: SR(state=False)
In [6]: flipflop1(in_set=True, in_reset=True)
Out[6]: False
In [7]: flipflop1(in_set=True, in_reset=False)
Out[7]: True
In [8]: flipflop1
Out[8]: SR(state=True)
In [9]: bool(flipflop1)
Out[9]: True
In [10]: int(flipflop1)
Out[10]: 1
In [11]: flipflop1 << 2
Out[11]: 4

Diese Magic-Methoden finde ich einfach cool. Könnte man noch mit logischen Operationen erweitern (__and__, __or__, __xor__).
Sind hier eigentlich noch Menschen unterwegs, die SPS programmieren?