Python中管理类常量实例与避免循环依赖的策略

# 为了演示问题，我们先定义一个简化的 Context 类
class Context:
    def __init__(self, just_beginning: bool):
        self.just_beginning = just_beginning

class State:
    # 这里的 StartState 和 EndState 在定义时尚未被定义，会引发 NameError
    # 为了避免语法错误，这里使用字符串前向引用，但运行时仍会失败
    START: 'State' = StartState()
    END: 'State' = EndState()

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

class StartState(State):
    """具体的开始状态类"""
    pass

class EndState(State):
    """具体的结束状态类"""
    pass

# 尝试执行上述代码会导致 NameError
# 例如：
# try:
#     context = Context(True)
#     current_state = State.get_current(context)
#     print(current_state)
# except NameError as e:
#     print(f"发生错误: {e}") # 输出: NameError: name 'StartState' is not defined

class State:
    """基状态类，可作为所有具体状态的抽象基类。"""
    pass

# 在 State 类定义之后，定义具体的全局状态实例
# 遵循 Python 常量命名规范：使用全大写字母
START_STATE = State()
END_STATE = State()

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 State:
    """基状态类，可作为所有具体状态的抽象基类。"""
    pass

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

# 在所有相关类定义之后，定义具体的全局状态实例
# 遵循 Python 常量命名规范：使用全大写字母
START_STATE = State()
END_STATE = State()

# 示例用法
print("--- 解决方案示例 ---")
context_beginning = Context(True)
current_state_1 = context_beginning.get_state()
print(f"当前状态 (开始): {current_state_1}")

context_end = Context(False)
current_state_2 = context_end.get_state()
print(f"当前状态 (结束): {current_state_2}")

# 验证它们是同一个实例（单例行为）
print(f"START_STATE 和 current_state_1 是否相同: {START_STATE is current_state_1}") # True
print(f"END_STATE 和 current_state_2 是否相同: {END_STATE is current_state_2}")     # True

class State:
    """基状态类，定义了所有状态的通用接口。"""
    def execute(self):
        raise NotImplementedError("子类必须实现 execute 方法")

class StartState(State):
    """具体的开始状态，具有其特有的行为。"""
    def execute(self):
        print("执行开始状态特有的逻辑...")

class EndState(State):
    """具体的结束状态，具有其特有的行为。"""
    def execute(self):
        print("执行结束状态特有的逻辑...")

# 在所有类定义之后，创建子类的实例作为常量
# 依然使用全大写命名规范，表示这些是全局唯一的常量实例
GLOBAL_START_STATE = StartState()
GLOBAL_END_STATE = EndState()

# 此时，Context 可能会这样使用它们来管理状态转换和行为
class Context:
    def __init__(self, initial_state: State):
        self._current_state = initial_state

    def transition_to(self, new_state: State):
        print(f"从 {type(self._current_state).__name__} 转换到 {type(new_state).__name__}")
        self._current_state = new_state

    def perform_action(self):
        self._current_state.execute()

# 示例用法
print("\n--- 带有独立子