Python中如何实现带访问限制的方法与类链式调用

核心实现逻辑非常简单：链式调用的本质是每个方法执行完成后，返回对应类的实例对象。要实现「特定方法只能在某些步骤后调用」的限制，只需要把不同阶段可用的方法拆分到不同的类中，对应步骤执行完成后返回对应类的实例即可，没有到对应步骤时，实例根本不会暴露后续方法，自然无法调用。

具体实现代码 #

先实现你要求的3种场景 #

# F_A1调用后返回的中间类，仅存放F_A1执行后才能调用的方法
class ClassAIntermediate:
    def __init__(self, a1_result):
        # 存储F_A1的执行结果，供后续方法使用
        self.a1_result = a1_result

    def F_A2(self):
        # 这里直接使用F_A1的结果处理逻辑
        print(f"执行F_A2，依赖的F_A1结果为：{self.a1_result}")
        # 需要继续链式就返回对应实例，这里返回self支持后续同阶段方法调用
        return self

    def B(self):
        # 满足场景2：F_A1执行后才能调用ClassB相关方法
        return ClassB()

# 基础ClassA类
class ClassA:
    def F_A1(self):
        print("执行F_A1")
        a1_result = "F_A1的运行结果"
        # 返回中间类实例，将F_A1结果传递过去
        return ClassAIntermediate(a1_result)

    def B(self):
        # 满足场景3：ClassA实例可直接调用ClassB相关方法
        return ClassB()

# ClassB类，存放ClassB专属方法
class ClassB:
    def F_B1(self):
        print("执行ClassB的F_B1方法")
        return self

场景测试 #

# 场景1：F_A2仅在F_A1之后可用
ClassA().F_A1().F_A2()
# 直接执行ClassA().F_A2()会直接报错，符合限制要求

# 场景2：F_A1后调用ClassB的方法
ClassA().F_A1().B().F_B1()

# 场景3：ClassA直接调用ClassB
ClassA().B().F_B1()

你给出的cars示例实现 #

如果没有严格的调用顺序限制，只是常规的属性设置链式调用，所有方法返回self即可：

class CarsQuery:
    def __init__(self):
        self.__brand = None
        self.__color = None

    def brand(self, brand_name: str):
        self.__brand = brand_name
        return self

    def color(self, color_name: str):
        self.__color = color_name
        return self

    def __repr__(self):
        return f"返回{self.__color} {self.__brand}的车辆列表"

def cars():
    return CarsQuery()

测试效果 #

print(cars().brand('Audi').color('red'))
# 输出：返回red Audi的车辆列表

小提示：给方法加上返回值类型注解后，IDE会自动提示对应阶段可用的方法，使用体验更好。

内容的提问来源于stack exchange，提问作者Cas