Building a Simple State Machine in Python

Introduction to State Machines

A state machine is a computational model used to represent the behavior of a system in response to events or inputs. It consists of a set of states, transitions between those states, and actions associated with each transition. State machines are commonly used in software development to model complex processes, workflows, or systems.

In this article, we’ll explore how to build a simple state machine in Python from scratch. We’ll walk through the process step by step, using code examples to illustrate each concept.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Python programming.

Step 1: Defining States and Transitions

Let’s consider a simple example of a light bulb that can be in two states: “on” and “off.” The light bulb can transition from the “off” state to the “on” state when a “turn on” event occurs, and from the “on” state to the “off” state when a “turn off” event occurs.

class LightBulb:
    def __init__(self):
        self.state = "off"

    def turn_on(self):
        self.state = "on"
        print("Light bulb is on.")

    def turn_off(self):
        self.state = "off"
        print("Light bulb is off.")

Step 2: Implementing the State Machine

Now that we have defined the states and transitions, let’s implement the state machine. We’ll create an instance of the LightBulb class and simulate turning the light bulb on and off.

def main():
    light_bulb = LightBulb()

    print("Initial state:", light_bulb.state)

    light_bulb.turn_on()
    print("Current state:", light_bulb.state)

    light_bulb.turn_off()
    print("Current state:", light_bulb.state)

if __name__ == "__main__":
    main()

In this example, we create a LightBulb instance and initially print its state. Then, we call the turn_on method to transition the light bulb to the “on” state and print the updated state. Finally, we call the turn_off method to transition the light bulb back to the “off” state and print the final state.

Adding Transitions with Actions

In a more elaborate state machine, transitions between states often involve performing actions. Let’s enhance our light bulb example to include actions when transitioning between “on” and “off” states.

class LightBulb:
    def __init__(self):
        self.state = "off"

    def turn_on(self):
        if self.state == "off":
            self.state = "on"
            self._print_state_change("on")

    def turn_off(self):
        if self.state == "on":
            self.state = "off"
            self._print_state_change("off")

    def _print_state_change(self, new_state):
        print(f"Light bulb switched from {self.state} to {new_state}.")

In this version of the LightBulb class, we’ve added a private method _print_state_change to print a message whenever the state changes. This method is used to provide feedback when the light bulb transitions between “on” and “off” states.

Using the Enhanced State Machine

Let’s modify our main program to make use of the enhanced state machine with actions:

def main():
    light_bulb = LightBulb()

    print("Initial state:", light_bulb.state)

    light_bulb.turn_on()
    light_bulb.turn_on()  # Try turning on when already on
    light_bulb.turn_off()
    light_bulb.turn_off()  # Try turning off when already off

if __name__ == "__main__":
    main()

In this example, we create a LightBulb instance, turn it on, and then attempt to turn it on again (which will not have any effect since it’s already on). We then turn it off and attempt to turn it off again.

The output of the program will demonstrate the state transitions and the associated actions:

Initial state: off
Light bulb switched from off to on.
Light bulb is already on.
Light bulb switched from on to off.
Light bulb is already off.

Conclusion

By enhancing our simple state machine with actions, we’ve created a more realistic representation of how state transitions can trigger specific behaviors. State machines are invaluable tools for modeling and managing complex processes, whether in software applications, automation systems, or other domains. By understanding the principles of state machines, you can design more structured and organized systems that respond predictably to various inputs and events.