Python état-conception d'une machine

En avril, 2009 de Python Magazine, j'ai écrit un article sur l'incorporation d'un État DSL dans Python, en utilisant pyparsing et imputil. Ce code vous permettra d'écrire le module de feux.pystate:

# trafficLight.pystate

# define state machine
statemachine TrafficLight:
    Red -> Green
    Green -> Yellow
    Yellow -> Red

# define some class level constants
Red.carsCanGo = False
Yellow.carsCanGo = True
Green.carsCanGo = True

Red.delay = wait(20)
Yellow.delay = wait(3)
Green.delay = wait(15)

et le DSL compilateur de créer tous les Feux, Rouge, Jaune, et Vert des classes, et le bon état de transition méthodes. Code pourrait appeler ces classes en utilisant quelque chose comme ceci:

import statemachine
import trafficLight

tl = trafficLight.Red()
for i in range(6):
    print tl, "GO" if tl.carsCanGo else "STOP"
    tl.delay()
    tl = tl.next_state()

(Malheureusement, imputil a été abandonné en Python 3.)

J'ai aussi n'a pas été heureux avec les options actuelles pour state_machines j'ai donc écrit le state_machine bibliothèque.

Vous pouvez l'installer en pip install state_machine et de l'utiliser comme ceci:

@acts_as_state_machine
class Person():
    name = 'Billy'

    sleeping = State(initial=True)
    running = State()
    cleaning = State()

    run = Event(from_states=sleeping, to_state=running)
    cleanup = Event(from_states=running, to_state=cleaning)
    sleep = Event(from_states=(running, cleaning), to_state=sleeping)

    @before('sleep')
    def do_one_thing(self):
        print "{} is sleepy".format(self.name)

    @before('sleep')
    def do_another_thing(self):
        print "{} is REALLY sleepy".format(self.name)

    @after('sleep')
    def snore(self):
        print "Zzzzzzzzzzzz"

    @after('sleep')
    def big_snore(self):
        print "Zzzzzzzzzzzzzzzzzzzzzz"

person = Person()
print person.current_state == person.sleeping       # True
print person.is_sleeping                            # True
print person.is_running                             # False
person.run()
print person.is_running                             # True
person.sleep()

# Billy is sleepy
# Billy is REALLY sleepy
# Zzzzzzzzzzzz
# Zzzzzzzzzzzzzzzzzzzzzz

print person.is_sleeping                            # True

Cela dépend probablement sur le degré de complexité de votre machine d'état est. Pour de simples machines d'état, un dict des dicts (des événements-clés de l'état-clés pour DFAs, ou des événements-clés de listes/jeux/n-uplets de l'état-clés pour les Fan) sera probablement la chose la plus simple à écrire et à comprendre.

Pour les plus complexes de l'état des machines, j'ai entendu de bonnes choses au sujet de SMC, qui permet de compiler déclarative de l'état de la machine descriptions de code dans une grande variété de langues, y compris Python.

Je n'hésiterais pas à recommander l'application d'un tel bien connu motif de vous. Il suffit d'aller pour une implémentation open source comme les transitions et enveloppez-les d'une autre classe autour d'elle si vous avez besoin de fonctionnalités personnalisées. Dans ce post je vais expliquer pourquoi je préfère cette mise en œuvre et de ses caractéristiques.

Je ne pense pas à atteindre pour une machine à états finis pour le traitement XML. La manière habituelle pour ce faire, je pense, est d'utiliser une pile:

class TrackInfoHandler(object):
def __init__(self):
self._stack=[]
## ================================== Event callbacks
def startElement(self, name, attrs):
cls = self.elementClasses[name]
self._stack.append(cls(**attrs))
def characters(self, ch):
self._stack[-1].addCharacters(ch)
def endElement(self, name):
e = self._stack.pop()
e.close()
if self._stack:
self._stack[-1].addElement(e)

Pour chaque type d'élément, vous avez juste besoin d'une classe qui prend en charge la addCharacters, addElement, et close méthodes.

EDIT: À préciser, oui, je ne veux soutenir que des machines à états finis sont généralement la mauvaise réponse, que comme une technique de programmation, ils sont de la foutaise et vous devriez rester loin.

Il y a un peu de vraiment bien comprise, bien délimitées, les problèmes pour lesquels les Smqs sont une solution sympa. lex, par exemple, est quelque chose de bon.

Cela dit, FSMs n'est généralement pas bien composer avec le changement. Supposons qu'un jour vous voulez ajouter un peu de l'état, peut-être un "avons-nous vu de l'élément X encore?" pavillon. Dans le code ci-dessus, vous ajoutez un attribut booléen à l'élément de classe et vous avez terminé. Dans une machine à état fini, on double le nombre d'états et de transitions.

Des problèmes qui nécessitent des états finis au premier abord très souvent évoluer pour exiger encore plus de l'état, comme peut-être un nombre, à quel point votre FSM régime est grillé, ou pire, de vous faire évoluer dans une sorte de généralisation de l'état de la machine, et à ce stade, vous êtes vraiment dans le pétrin. Le plus vous allez, plus vos règles commencent à agir comme code, mais le code dans un lent langage interprété que vous avez inventé que personne d'autre ne sait, pour qui il n'y a pas de débogueur et sans outils.

Voici une solution pour les "statefull objets", je suis venu avec, mais c'est plutôt inefficace pour votre usage prévu, parce que les modifications de l'état sont relativement chers. Toutefois, il peut bien fonctionner pour les objets qui changent d'état rarement ou faire l'objet que d'un délimitée nombre de changements d'état. L'avantage est qu'une fois que l'état est changé, il n'est pas redondant indirection.

class T:
"""
Descendant of `object` that rectifies `__new__` overriding.
This class is intended to be listed as the last base class (just
before the implicit `object`).  It is a part of a workaround for
* https://bugs.python.org/issue36827
"""
@staticmethod
def __new__(cls, *_args, **_kwargs):
return object.__new__(cls)
class Stateful:
"""
Abstract base class (or mixin) for "stateful" classes.
Subclasses must implement `InitState` mixin.
"""
@staticmethod
def __new__(cls, *args, **kwargs):
# XXX: see https://stackoverflow.com/a/9639512
class CurrentStateProxy(cls.InitState):
@staticmethod
def _set_state(state_cls=cls.InitState):
__class__.__bases__ = (state_cls,)
class Eigenclass(CurrentStateProxy, cls):
__new__ = None  # just in case
return super(__class__, cls).__new__(Eigenclass, *args, **kwargs)
# XXX: see https://bugs.python.org/issue36827 for the reason for `T`.
class StatefulThing(Stateful, T):
class StateA:
"""First state mixin."""
def say_hello(self):
self._say("Hello!")
self.hello_count += 1
self._set_state(self.StateB)
return True
def say_goodbye(self):
self._say("Another goodbye?")
return False
class StateB:
"""Second state mixin."""
def say_hello(self):
self._say("Another hello?")
return False
def say_goodbye(self):
self._say("Goodbye!")
self.goodbye_count += 1
self._set_state(self.StateA)
return True
# This one is required by `Stateful`.
class InitState(StateA):
"""Third state mixin -- the initial state."""
def say_goodbye(self):
self._say("Why?")
return False
def __init__(self, name):
self.name = name
self.hello_count = self.goodbye_count = 0
def _say(self, message):
print("{}: {}".format(self.name, message))
def say_hello_followed_by_goodbye(self):
self.say_hello() and self.say_goodbye()
# ----------
# ## Demo ##
# ----------
if __name__ == "__main__":
t1 = StatefulThing("t1")
t2 = StatefulThing("t2")
print("> t1, say hello.")
t1.say_hello()
print("> t2, say goodbye.")
t2.say_goodbye()
print("> t2, say hello.")
t2.say_hello()
print("> t1, say hello.")
t1.say_hello()
print("> t1, say hello followed by goodbye.")
t1.say_hello_followed_by_goodbye()
print("> t2, say goodbye.")
t2.say_goodbye()
print("> t2, say hello followed by goodbye.")
t2.say_hello_followed_by_goodbye()
print("> t1, say goodbye.")
t1.say_goodbye()
print("> t2, say hello.")
t2.say_hello()
print("---")
print( "t1 said {} hellos and {} goodbyes."
.format(t1.hello_count, t1.goodbye_count) )
print( "t2 said {} hellos and {} goodbyes."
.format(t2.hello_count, t2.goodbye_count) )
# Expected output:
#
#     > t1, say hello.
#     t1: Hello!
#     > t2, say goodbye.
#     t2: Why?
#     > t2, say hello.
#     t2: Hello!
#     > t1, say hello.
#     t1: Another hello?
#     > t1, say hello followed by goodbye.
#     t1: Another hello?
#     > t2, say goodbye.
#     t2: Goodbye!
#     > t2, say hello followed by goodbye.
#     t2: Hello!
#     t2: Goodbye!
#     > t1, say goodbye.
#     t1: Goodbye!
#     > t2, say hello.
#     t2: Hello!
#     ---
#     t1 said 1 hellos and 1 goodbyes.
#     t2 said 3 hellos and 2 goodbyes.

J'ai posté une "demande de commentaires" ici.