Python State Design Pattern

1. Definition

The State Design Pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class.

2. Problem Statement

Imagine you have an object with multiple conditional statements throughout its methods to control behavior based on the object's state. As more states are added, these conditions become complex, hard to manage, and error-prone. How can you simplify this?

3. Solution

The State Pattern suggests that you create new classes for all possible states of an object (ConcreteState) and extract the state-specific behaviors to these classes. Instead of implementing state behaviors within the context itself, delegate the work to the state class.

4. Real-World Use Cases

1. A media player transitioning between Play, Pause, and Stop states.

2. A traffic light that changes its behavior based on its current state: Red, Yellow, Green.

3. A game character that changes its behavior based on health levels: Normal, Poisoned, Paralyzed.

5. Implementation Steps

1. Declare an abstract state interface.

2. Implement concrete state classes for each possible state.

3. Define the context class that maintains an instance of one of the concrete state classes.

4. The context delegates the state-specific behavior to the active state object.

6. Implementation in Python

# Abstract State
class State:
    def handle_request(self):
        pass
# Concrete States
class PlayState(State):
    def handle_request(self):
        return "Playing..."
class PauseState(State):
    def handle_request(self):
        return "Paused..."
class StopState(State):
    def handle_request(self):
        return "Stopped..."
# Context
class MediaPlayer:
    def __init__(self):
        self.state = StopState()
    def set_state(self, state: State):
        self.state = state
    def play(self):
        self.state = PlayState()
    def pause(self):
        self.state = PauseState()
    def stop(self):
        self.state = StopState()
    def handle_request(self):
        return self.state.handle_request()
# Client code
player = MediaPlayer()
print(player.handle_request())  # Initially, the player is stopped.
player.play()
print(player.handle_request())  # Now, the player is playing.
player.pause()
print(player.handle_request())  # The player is paused.
player.stop()
print(player.handle_request())  # The player is stopped again.

Output:

Stopped...
Playing...
Paused...
Stopped...

Explanation:

1. The abstract State class provides a handle_request method.

2. Concrete state classes like PlayState, PauseState, and StopState implement this method to provide state-specific behavior.

3. The MediaPlayer class (context) maintains a reference to a state object that represents its current state.

4. Upon calling state-related methods like play(), pause(), and stop(), the context changes its current state.

5. For any behavior that depends on the state (like handle_request()), the context delegates the handling to the current state object.

7. When to use?

Use the State Pattern when:

1. An object's behavior changes depending on its state, and it must change its behavior at runtime depending on that state.

2. Operations have large, multi-way conditional statements that depend on the object's state. This state is usually represented by one or more enumerated constants.