Python状态机设计

Question

您是否可以与我（和社区）分享的人对Python状态机的设计技巧？

目前，我将基于以下方面来选择引擎：

class TrackInfoHandler(object):
    def __init__(self):
        self._state="begin"
        self._acc=""

    ## ================================== Event callbacks

    def startElement(self, name, attrs):
        self._dispatch(("startElement", name, attrs))

    def characters(self, ch):
        self._acc+=ch

    def endElement(self, name):
        self._dispatch(("endElement", self._acc))
        self._acc=""

    ## ===================================
    def _missingState(self, _event):
        raise HandlerException("missing state(%s)" % self._state)

    def _dispatch(self, event):
        methodName="st_"+self._state
        getattr(self, methodName, self._missingState)(event)

    ## =================================== State related callbacks

但是我敢肯定，在利用Python的动态特性（例如动态调度）的同时，有很多解决方法。

我追求的是针对“引擎”的设计技术，该技术接收与基于机器“状态”的事件和“事件”相对的“事件”和“事件”。

Answer 1

我真的不明白这个问题。该 国设计模式是相当清楚的。。

class SuperState( object ):
    def someStatefulMethod( self ):
        raise NotImplementedError()
    def transitionRule( self, input ):
        raise NotImplementedError()

class SomeState( SuperState ):
    def someStatefulMethod( self ):
        actually do something()
    def transitionRule( self, input ):
        return NextState()

这是非常常见的样板，可用于Java，C ++，Python（而且我敢肯定也可以使用其他语言）。

如果您的状态转换规则很琐碎，可以进行一些优化以将转换规则本身推入超类。

注意，我们需要有前向引用，因此我们通过名称引用类，并用于eval将类名称转换为实际的类。另一种方法是使转换规则实例变量代替类变量，然后在定义所有类之后创建实例。

class State( object ):
    def transitionRule( self, input ):
        return eval(self.map[input])()

class S1( State ): 
    map = { "input": "S2", "other": "S3" }
    pass # Overrides to state-specific methods

class S2( State ):
    map = { "foo": "S1", "bar": "S2" }

class S3( State ):
    map = { "quux": "S1" }

在某些情况下，您的事件并不像测试对象的相等性那么简单，因此更通用的转换规则是使用功能对象对的正确列表。

class State( object ):
    def transitionRule( self, input ):
        next_states = [ s for f,s in self.map if f(input)  ]
        assert len(next_states) >= 1, "faulty transition rule"
        return eval(next_states[0])()

class S1( State ):
    map = [ (lambda x: x == "input", "S2"), (lambda x: x == "other", "S3" ) ]

class S2( State ):
    map = [ (lambda x: "bar" <= x <= "foo", "S3"), (lambda x: True, "S1") ]

由于规则是按顺序评估的，因此允许使用“默认”规则。