Python中管理状态实例的有效方法：避免循环引用与优化设计

# 假设我们尝试这样定义
class State:
    # 尝试将子类实例作为类变量
    START: "State" = StartState()  # 这里会引发 NameError
    END: "State" = EndState()      # 这里会引发 NameError

    @classmethod
    def get_current(cls, context: "Context") -> "State":
        if context.just_beginning:
            return cls.START
        return cls.END

class StartState(State):
    # ... StartState 特有的行为 ...
    pass

class EndState(State):
    # ... EndState 特有的行为 ...
    pass

# 假设 Context 类如下
class Context:
    def __init__(self, just_beginning: bool):
        self.just_beginning = just_beginning

class State:
    """
    状态基类，可以定义所有状态共享的行为。
    """
    pass

# 在所有类定义之后，在模块级别定义固定的状态实例
START_STATE = State()
END_STATE = State()

# 示例：一个更复杂的 State 子类，如果需要特定行为
class ActiveState(State):
    def perform_action(self):
        print("Performing action in Active State.")

ACTIVE_STATE = ActiveState() # 同样在模块级别实例化

class Context:
    """
    上下文类，负责管理其当前状态。
    """
    def __init__(self, just_beginning: bool):
        self.just_beginning = just_beginning
        # 可以在这里初始化一个默认状态，或根据需要设置

    def get_state(self) -> State:
        """
        根据上下文的内部条件返回相应的状态实例。
        """
        if self.just_beginning:
            return START_STATE
        return END_STATE

# 假设一个更复杂的上下文，可能需要多个状态
class PlayerContext(Context):
    def __init__(self, health: int, is_alive: bool):
        super().__init__(is_alive and health > 0) # 简化示例
        self.health = health
        self.is_alive = is_alive

    def get_state(self) -> State:
        if not self.is_alive or self.health <= 0:
            return END_STATE # 玩家死亡状态
        elif self.just_beginning:
            return START_STATE # 游戏开始状态
        else:
            return ACTIVE_STATE # 活跃游戏状态

# 1. 定义状态基类
class State:
    """
    状态基类，所有具体状态的父类。
    """
    def __str__(self):
        return self.__class__.__name__

    def handle(self, context: "Context"):
        """
        状态可以定义通用的处理逻辑。
        """
        print(f"Handling in generic State: {self}")

# 2. 定义具体的子状态类（如果它们有独特的行为）
class ActiveState(State):
    def handle(self, context: "Context"):
        print(f"Handling in ActiveState. Context is_beginning: {context.just_beginning}")
        # ActiveState 特有的逻辑
        # context.transition_to(ANOTHER_STATE)

class InitialState(State):
    def handle(self, context: "Context"):
        print(f"Handling in InitialState. Setting up initial conditions.")
        # 初始化逻辑
        # context.transition_to(ACTIVE_STATE)

# 3. 在模块级别实例化所有固定的状态对象
#    如果状态不需要独特的行为，直接使用 State() 即可
START_STATE = InitialState() # 使用 InitialState 作为开始状态
END_STATE = State()          # 结束状态可能不需要特殊行为
ACTIVE_GAME_STATE = ActiveState() # 活跃游戏状态

# 4. 定义上下文类，负责管理和提供当前状态
class Context:
    """
    上下文类，负责维护其当前状态，并根据条件提供相应的状态实例。
    """
    def __init__(self, just_beginning: bool = True):
        self.just_beginning = just_beginning
        self._current_state: State = START_STATE # 初始化上下文的当前状态

    def transition_to(self, state: State):
        """
        允许上下文转换到新的状态。
        """
        print(f"Context: Transitioning from {self._current_state} to {state}")
        self._current_state = state

    def get_current_state(self) -> State:
        """
        根据上下文的内部条件返回相应的状态实例。
        这个方法可以包含更复杂的逻辑来决定当前状态。
        """
        if self.just_beginning:
            return START_STATE
        # 假设有一些其他条件来决定是结束状态还是活跃状态
        # For simplicity, let's just use the internal _current_state
        return self._current_state

    def request(self):
        """
        上下文将请求委托给其当前状态。
        """
        print("Context: Requesting state to handle.")
        self._current_state.handle(self)

# 5. 示例用法
if __name__ == "__main__":
    print("--- 场景一：初始上下文 ---")
    context1 = Context(just_beginning=True)
    current_state1 = context1.get_current_state()
    print(f"Context 1 current state: {current_state1}")
    context1.request() # 初始状态处理

    print("\n--- 场景二：非初始上下文，转换状态 ---")
    context2 = Context(just_beginning=False)
    context2.transition_to(ACTIVE_GAME_STATE) # 转换为活跃状态
    current_state2 = context2.get_current_state()
    print(f"Context 2 current state: {current_state2}")
    context2.request() # 活跃状态处理

    print("\n--- 场景三：结束状态 ---")
    context3 = Context(just_beginning=False)
    context3.transition_to(END_STATE)
    current_state3 = context3.get_current_state()
    print(f"Context 3 current state: {current_state3}")
    context3.request() # 结束状态处理