事件驱动的有限状态机中的转换

Question

我在python中使用Transitions来实现有限状态机事件驱动。

我想实现一个FSM，其中转换由通过避免if/elif语句处理的事件触发。

例如：我有一个简单的灯的FSM，如果它(以非确定性的方式(到达'goInlampOn'事件，我们将移动到"打开"状态，如果'goInlampOff'事件到达，我们将移到'off'状态。

所以我的问题是：

有没有一种方法可以在FSM类中创建一个名为process_event(event)的方法，该方法使用FSM的逻辑处理每个事件，而不使用很长(在这种情况下不是很简单(的if-elif语句

下面是一个代码示例：

class MyFsm(object):
transitions = [
{'trigger': 'switchOff', 'source':'on', 'dest':'off'},
{'trigger': 'switchOn', 'source':'off', 'dest':'on'}
]
def __init__(self):
''' initialating the FSM '''
self.machine = Machine(model=self, states=self.states,
transitions=self.transitions, initial='on')
on = On()
off = Off()
self.machine.add_state(off)
self.machine.add_state(on)
# A SMART SOLUTION TO IMPLEMENT THIS METHOD WITHOUT USING
# if state == off: ... elif state==on...
def process_event(self,event):
if self.state == 'off':
if event == 'goInlampOn':
self.switchOn()
elif self.state == 'on':
if event == 'goInlampOff':
self.switchOff()

在我介绍的情况下，只有两个状态，但如果我有10个或15个？我试图实现我认为@aleneum向我建议的解决方案。然而，在这个解决方案中，我必须记录两次状态机的转换。它是正确的吗？是否有更好的解决方案(避免两次编写转换(？这是一个有4个状态(a、B、C、D(的状态机，唯一允许的转换是：
1。A->B
2.B->C
3。C->D
4.D->A
5。C->A
这里的代码：

from transitions import Machine
from states import A,B,C,D
class MyFsm(object):
transitions = [
{'trigger': 'go_in_B_fromA','source':'A','dest':'B'},
{'trigger': 'go_in_C_fromB','source':'B','dest':'C'},
{'trigger': 'go_in_D_fromC','source':'C','dest':'D'},
{'trigger': 'go_in_A_fromD','source':'D','dest':'A'},
{'trigger': 'go_in_A_fromC','source':'C','dest':'A'},        
{'trigger': 'go_in_B_fromA','source':['C','D','B'],'dest':None},
{'trigger': 'go_in_C_fromB','source':['C','D','A'],'dest':None},
{'trigger': 'go_in_D_fromC','source':['B','D','A'],'dest':None},
{'trigger': 'go_in_A_fromD','source':['B','A','C'],'dest':None},
{'trigger': 'go_in_A_fromC','source':['D','A','B'],'dest':None}
]
def __init__(self):   
self.machine = Machine(model=self, states = self.states ,transitions= self.transitions, initial = 'A' )       
a = A()
b = B()
c = C()
d = D()       
self.machine.add_state(a)
self.machine.add_state(b)
self.machine.add_state(c)
self.machine.add_state(d)

def process_event(self,event):   
if event == 'go_in_B_fromA' :
self.go_in_B_fromA()
if event == 'go_in_C_fromB' :
self.go_in_C_fromB()
if event == 'go_in_D_fromC' :
self.go_in_D_fromC()
if event == 'go_in_A_fromD' :
self.go_in_A_fromD()
if event == 'go_in_A_fromC' :
self.go_in_A_fromC()
'''my main is something like this'''
myfsm = MyFsm()
while True:
event = event_from_external_bahaviour()
myfsm.process_event(event)

Answer 1

正如@martineau所提到的，事件的影响/模型的行为应该由其当前状态决定。实际上，使用状态机可以避免大量的if/then语句。看看下面的代码片段：

from transitions.core import Machine, State, MachineError
class On(State):
def __init__(self, *args, **kwargs):
super(On, self).__init__(*args, **kwargs)
class Off(State):
def __init__(self, *args, **kwargs):
super(Off, self).__init__(*args, **kwargs)

class MyFsm(object):
transitions = [
{'trigger': 'switchOff', 'source':'on', 'dest':'off'},
{'trigger': 'switchOn', 'source':'off', 'dest':'on'}
]
def __init__(self):
# ignore_invalid_triggers will allow to process events not defined for a state
on = On(name='on', ignore_invalid_triggers=True)
off = Off(name='off', ignore_invalid_triggers=False)
self.machine = Machine(model=self, states=[on, off], transitions=self.transitions, initial='on')
machine = MyFsm()
print(machine.state)  # >>> on
machine.switchOff()
print(machine.state)  # >>> off
try:
# this will raise a MachineException because there is no transition 'switchOff'
# defined in state 'off'
machine.switchOff()  # raises MachineException
raise Exception("This exception will not be raised")
except MachineError:
pass
print(machine.state)  # >>> off
machine.switchOn()
print(machine.state)  # >>> on
# this will NOT raise an Exception since we configured 'on'
# to ignore transitions not defined for this state
machine.switchOn()
print(machine.state)  # >>> on

我为On和Off定义了一些占位符类，因为我认为您希望使用自定义状态类。transitions使您能够在不跟踪当前状态的情况下直接触发模型的方法。您的配置将决定将会发生什么。根据您的需要，如果触发了一个未为您的状态定义的方法，则可以引发MachineError。考虑到你的例子，我建议忽略无效的触发器，因为尝试打开或关闭一盏灯两次并不是什么大事。另一个解决方案是"循环"状态或使用内部转换，如果你想避免无效的触发器：

# leaves and enters state off even if its already off
# processes all on_enter/exit callbacks
{'trigger': 'switchOff', 'source':['on', 'off'], 'dest':'off'}
# an internal transition is defined by having dest set to 'None'
# processes no state callbacks
{'trigger': 'switchOff', 'source': 'off', 'dest': None}

这在很大程度上取决于你的用例和你用这个状态机实际控制的系统，哪种行为是首选的。

Answer 2

我不确定我是否理解你的问题，因为使用类似库的转换的目的是避免编写长的if-else if链。此外，文档中从未提及您应该重新实现process_event()。

因此，我只能用您的示例将文档转述为转换，而不能使用ifs。我希望它能帮助你。

from transitions import Machine

class Model:
def __init__(self):
self.machine = Machine(
model=self,
states=["on", "off"],
transitions=[
{
"trigger": "switchOff",
"source": "on",
"dest": "off",
},
{
"trigger": "switchOn",
"source": "off",
"dest": "on",
},
],
initial="on",
ignore_invalid_triggers=True,
)

m = Model()
assert m.state == "on"
# We are in state 'on' and there is not 'switchOn'
# transition defined: nothing happens.
#
# Without `ignore_invalid_triggers`, transitions
# would raise an exception.
m.switchOn()
assert m.state == "on"
# We still are in 'on' and 'switchOff' brings
# us to 'off.
m.switchOff()
assert m.state == "off"

你可以考虑阅读维基百科上关于UML状态机的文章，例如，当转换离实现它很近的时候