an example of finite state machine from this youtube video https://www.youtube.com/watch?v=E45v2dD3IQU

robotmaidfsm.py

from random import randint
from time import clock

class Transition(object):
    def __init__(self,toState):
        self.toState = toState

    def execute(self):
        print("--Transitioning-- to %s" % self.toState)

class State(object):
    def __init__(self, FSM):
        self.FSM = FSM
        self.timer = 0
        self.startTime = 0

    def enter(self):
        self.timer = randint(0,5)
        self.startTime = int(clock())

    def execute(self):
        pass

    def end(self):
        pass

class CleanDishes(State):
    def __init__(self, FSM):
        self.FSM = FSM
        self.timer = 0
        self.startTime = 0

    def enter(self):
        print("Preparing to clean dishes.")
        super(CleanDishes, self).enter()

    def execute(self):
        print("Cleaning dishes")
        if(self.startTime + self.timer <= clock()):
            if not (randint(1,3) % 2):
                self.FSM.toTransition("toVacuum")
            else: 
                self.FSM.toTransition("toSleep")
    
    def end(self):
        print("Finished cleaning dishes")

class Vacuum(State):
    def __init__(self, FSM):
        super(Vacuum, self).__init__(FSM)

    def enter(self):
        print("Starting to Vacuum")
        super(Vacuum, self).enter()

    def execute(self):
        print("Vacuuming")
        if(self.startTime + self.timer <= clock()):
            if not (randint(1,3) % 2):
                self.FSM.toTransition("toSleep")
            else:
                self.FSM.toTransition("toCleanDishes")
    
    def end(self):
        print("Finshed Vacuuming")

class Sleep(State):
    def __init__(self, FSM):
        super(Sleep, self).__init__(FSM)

    def enter(self):
        print("Starting to Sleep")
        super(Sleep, self).enter()

    def execute(self):
        print("Sleeping")
        if(self.startTime + self.timer <= clock()):
            if not (randint(1,3) % 2):
                self.FSM.toTransition("toVacuum")
            else:
                self.FSM.toTransition("toCleanDishes")
    
    def end(self):
        print("Waking up from Sleep")

class FSM(object):
    def __init__(self, character):
        self.char = character
        self.states = {}
        self.transitions = {}
        self.curState = None
        self.prevState = None # to prevent looping 2 states
        self.trans = None
    
    def addTransition(self, transName, transition):
        self.transitions[transName] = transition

    def addState(self, stateName, state):
        self.states[stateName] = state

    def setState(self, stateName):
        self.prevState = self.curState
        self.curState = self.states[stateName]

    def toTransition(self, toTrans):
        self.trans = self.transitions[toTrans]

    def execute(self):
        if(self.trans):
            self.curState.end()
            self.trans.execute()
            self.setState(self.trans.toState)
            self.curState.enter()
            self.trans = None
        self.curState.execute()
    
Char = type("Char", (object, ), {})

class RobotMaid(Char):
    def __init__(self):
        self.FSM = FSM(self)

        self.FSM.addState("Sleep", Sleep(self.FSM))
        self.FSM.addState("CleanDishes", CleanDishes(self.FSM))
        self.FSM.addState("Vacuum", Vacuum(self.FSM))

        self.FSM.addTransition("toSleep", Transition("Sleep"))
        self.FSM.addTransition("toCleanDishes", Transition("CleanDishes"))
        self.FSM.addTransition("toVacuum", Transition("Vacuum"))

        self.FSM.setState("Sleep")

    def execute(self):
        self.FSM.execute()

if __name__ == "__main__":
    r = RobotMaid()
    for i in range(10):
        startTime = clock()
        timeInterval = 1
        while(startTime + timeInterval > clock()):
            pass
        r.execute()