如何限制类实例对特定方法的访问？Python替代构造函数场景

下面提供几种比逐个方法校验更简便的实现方式：

方法一：子类限制法 #

通过替代构造函数返回一个限制子类的实例，子类重写需要禁止的方法并抛出错误，无需修改原类的方法逻辑：

class MyClass:
    def __init__(self, input1, input2):
        self.input1 = input1
        self.input2 = input2

    def method1(self):
        print("执行method1")

    def method2(self):
        print("执行method2")

    def method3(self):
        print("执行method3")

    @classmethod
    def alt_ctor(cls, input):
        # 定义仅允许访问method2的子类
        class RestrictedMyClass(cls):
            def method1(self):
                raise AttributeError("该实例无法访问method1")
            
            def method3(self):
                raise AttributeError("该实例无法访问method3")
        
        # 根据原类初始化逻辑传入参数，这里示例用input和None
        return RestrictedMyClass(input, None)

方法二：代理类包装法 #

创建一个代理类，仅暴露允许的方法，内部包装原类实例，完全隔离其他方法的访问：

class MyClass:
    def __init__(self, input1, input2):
        self.input1 = input1
        self.input2 = input2

    def method1(self):
        print("执行method1")

    def method2(self):
        print("执行method2")

    def method3(self):
        print("执行method3")

    @classmethod
    def alt_ctor(cls, input):
        # 先创建正常的MyClass实例
        raw_instance = cls(input, None)
        
        # 定义代理类，仅开放method2和必要属性
        class RestrictedProxy:
            def __init__(self, wrapped):
                self.wrapped = wrapped
            
            def method2(self):
                return self.wrapped.method2()
            
            # 如需开放属性，可通过__getattr__控制
            def __getattr__(self, name):
                if name in ["input1", "input2"]:
                    return getattr(self.wrapped, name)
                raise AttributeError(f"该实例无法访问{name}")
        
        return RestrictedProxy(raw_instance)

方法三：装饰器统一校验法 #

用装饰器给需要限制的方法统一添加校验逻辑，避免在每个方法里重复写判断：

from functools import wraps

# 定义限制装饰器
def restrict_alt_instance(func):
    @wraps(func)
    def wrapper(self, *args, **kwargs):
        if getattr(self, "_is_alt_instance", False):
            raise AttributeError(f"该实例无法访问{func.__name__}")
        return func(self, *args, **kwargs)
    return wrapper

class MyClass:
    def __init__(self, input1, input2):
        self.input1 = input1
        self.input2 = input2
        self._is_alt_instance = False  # 标记是否为替代构造实例

    @restrict_alt_instance
    def method1(self):
        print("执行method1")

    def method2(self):
        print("执行method2")

    @restrict_alt_instance
    def method3(self):
        print("执行method3")

    @classmethod
    def alt_ctor(cls, input):
        instance = cls(input, None)
        instance._is_alt_instance = True  # 标记为限制实例
        return instance

方法选择建议 #

• 若仅需限制少数方法，装饰器法最简洁，改动最小；
• 若需要严格隔离实例的方法与属性，代理类法更彻底；
• 若希望保留原类的继承关系，子类限制法更合适。

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