确保变量在任何给定时间仅处于一种状态

Question

Let's say we have a simulation of taxi movements. Each car at any given time, can be only in one of idle, rebalancing, serving states (just as an example, there are many more in my simulation). At any time, I have to check the state of each of the vehicles and act accordingly. For example, if a vehicle was idle and then picked up a passenger, its state should change from idle to serving . Importantly, at any given time the vehicle can only be in one of those states and its action set is also dependent on that state.

Currently, I am doing this with a long list of if-else checks, but feels very naive and it's very difficult to debug. For example, the main logic checks the state of a car first:

    if self.should_move():


        _ = _make_a_decision(t)
        self.update_rebalancing(WARMUP_PHASE)



    if self.is_busy():
        self.keep_serving()

    elif self.is_waiting_to_be_matched():
        # it's sitting somewhere
        self.keep_waiting()




    elif self.rebalancing:  # and not self.busy:
        self.update_rebalancing(WARMUP_PHASE)

Then any of those functions update its state accordingly, all including statements like this

    self.idle = False
    self.rebalancing = False
    self.serving = True
    self.time_idled = 0

There is a lot of repetition and easy to make mistakes.

I am wondering if

1. there is a programming pattern for this situation
2. If Python specifically has functionalities to handle this case

Answer 1

This is a really broad question and there's not any correct answer to it..

But to try to help, why not use a class?

class Taxi:
    # One variable to hold an enum of the states.
    self.state = 'idle'

    # function to update the state
    def setState(self, state):
        self.state = state

    # Functions to check the state (could have one to get the state and check later
    def isIdle(self):
        return self.state == 'idle' 

Then any functionality the taxi needs to do can be put in the class like:

    def pickupPassengers():
        if self.state != 'idle':
            return

        self.passengers += 1

Then you create your taxis and manage them through the class

taxi1 = Taxi()
taxi1.getPassengers()

Answer 2

There are a few ways to accomplish what you want. Since it can get confusing if you have to manually change multiple variables every time you have a state change... just have one variable in charge of the state! If you want to still be able to refer to Taxi.idle , Taxi.rebalancing , etc, then you can create @property methods. They look like functions when you define them but are called like properties.

See the example below for a Taxi class which has only one state variable, self._state and uses @property methods to return the status.

class Taxi:
    def __init__(self, initial_state = "idle"):
        self._state = initial_state


    @property
    def idle(self):
        return self._state == "idle"

    @property
    def rebalancing(self):
        return self._state == "rebalancing"

    @property
    def serving(self):
        return self._state == "serving"

    def serve(self):
        print("\nChanging state to serving\n")
        self._state = "serving"

T = Taxi() # Initialize taxi

print(f"Taxi is idle: {T.idle}")
print(f"Taxi is rebalancing: {T.rebalancing}")
print(f"Taxi is serving: {T.serving}")

T.serve()

print(f"Taxi is idle: {T.idle}")
print(f"Taxi is rebalancing: {T.rebalancing}")
print(f"Taxi is serving: {T.serving}")```

Output:

Taxi is idle: True
Taxi is rebalancing: False
Taxi is serving: False

Changing state to serving

Taxi is idle: False
Taxi is rebalancing: False
Taxi is serving: True

Answer 3

Your design problem is that you're trying to use a series of Booleans to embody one-hot encoding of a discrete variable (state). If you want only one value at a time, the natural way to do this is with a single variable. Enumeration types are what most advanced languages use for this. For instance, you can encode "idle" as 0, "rebalancing" as 1, etc.

Python code would look something like this:

from enum import Enum, unique, auto    

@unique
class TaxiState(Enum):

    IDLE  = auto()
    REBAL = auto()
    SERVE = auto()


class Taxi():

    def __init__(self):
        self.state = TaxiState.IDLE 

    def is_busy(self):
        return self.state != TaxiState.IDLE

You don't worry about the coding; auto handles that. All you do is use the enumeration name as a value. You get to code just as you designed that aspect of the model.