状态机模式

概括

状态机模式是编程中使用到的一种“行为型”设计模式，在写代码的过程中发现要根据某个变量的值去执行不同分支，写很多if else的时候可以用它来提高代码的逼格。

例子

class State:
    def insert_coin(self): pass
    def press_button(self): pass
    def dispense_product(self): pass

class WaitingState(State):
    def insert_coin(self):
        print("Coin inserted, ready to press button.")
        # 转换到已付款状态
    def press_button(self):
        print("Please insert a coin first.")

class PaidState(State):
    def insert_coin(self):
        print("Already paid, please press the button.")
    def press_button(self):
        print("Product dispensed.")
        # 转换到待付款状态

class SoldOutState(State):
    def insert_coin(self):
        print("Sold out, cannot insert coin.")
    def press_button(self):
        print("Sold out, no product to dispense.")

# 使用状态机
class VendingMachine:
    def __init__(self):
        self.state = WaitingState()
    def insert_coin(self):
        self.state.insert_coin()
    def press_button(self):
        self.state.press_button()

策略模式的区别？

策略模式：

class PaymentStrategy:
    def pay(self, amount):
        pass

class AlipayStrategy(PaymentStrategy):
    def pay(self, amount):
        print(f"Paying {amount} via Alipay.")

class WechatPayStrategy(PaymentStrategy):
    def pay(self, amount):
        print(f"Paying {amount} via Wechat Pay.")

class CreditCardStrategy(PaymentStrategy):
    def pay(self, amount):
        print(f"Paying {amount} via Credit Card.")

# 使用策略模式
class PaymentContext:
    def __init__(self, strategy: PaymentStrategy):
        self.strategy = strategy
    def make_payment(self, amount):
        self.strategy.pay(amount)

# 客户端代码
context = PaymentContext(AlipayStrategy())
context.make_payment(100)

context = PaymentContext(WechatPayStrategy())
context.make_payment(200)

写法很像，
状态机模式更多适用于某个状态一直在变化，并且它对应的行为不同，持续工作
策略模式，是在初始化的时候定义了本次行为适用的什么策略，进行的一整组的行为的定义。

都是ifelse的优化...倒是不必这么纠结他们的差异了，哈哈。

状态转换触发的代码怎么写？

class State:
    def on_enter(self, context):
        pass

    def on_exit(self, context):
        pass

class StateA(State):
    def on_enter(self, context):
        print("Entering State A")

    def on_exit(self, context):
        print("Exiting State A")

class StateB(State):
    def on_enter(self, context):
        print("Entering State B")

    def on_exit(self, context):
        print("Exiting State B")

class StateC(State):
    def on_enter(self, context):
        print("Entering State C")

    def on_exit(self, context):
        print("Exiting State C")

class Transition:
    def __init__(self, source_state_class, target_state_class, action, condition=lambda context: True):
        self.source_state_class = source_state_class
        self.target_state_class = target_state_class
        self.action = action
        self.condition = condition

class StateMachine:
    def __init__(self, initial_state_class):
        self.current_state = initial_state_class()
        self.current_state.on_enter(self)
        self.transitions = []
        self.transitions.append(Transition(StateA, StateC, action1))
        self.transitions.append(Transition(StateB, StateC, action2))

    def switch_to(self, target_state_class):
        for transition in self.transitions:
            if issubclass(self.current_state.__class__, transition.source_state_class) and issubclass(target_state_class, transition.target_state_class) and transition.condition(self):
                self.current_state.on_exit(self)
                transition.action(self)
                self.current_state = target_state_class()
                self.current_state.on_enter(self)
                return
        print(f"No transition from {self.current_state.__class__.__name__} to {target_state_class.__name__}")

# 动作定义
def action1(context):
    print("Executing action1")

def action2(context):
    print("Executing action2")