Python类访问控制：实现外部触发的getter/setter或排除__init__的访问器

针对你需要的「仅外部访问触发getter/setter」或「排除__init__的全局触发」需求，结合层级结构的属性锁定逻辑，以下是两种可行的实现方案：

方案一：基于@property + 栈帧判断（优先满足「仅外部访问触发」） #

通过inspect模块检查调用栈，区分类内部方法与外部访问，内部直接操作实例的__dict__跳过访问器，外部访问则触发校验与锁定逻辑：

import inspect

class HierarchyNode:
    def __init__(self, name):
        # 内部直接操作__dict__，完全绕过@property的访问器
        self.__dict__['name'] = name
        self.__dict__['_locked'] = False
        self.__dict__['_parent'] = None

    @property
    def name(self):
        # 检查调用者是否为类内部方法
        caller_frame = inspect.currentframe().f_back
        # 判断调用上下文是否属于当前实例的内部方法
        if caller_frame.f_locals.get('self') is self:
            return self.__dict__['name']
        # 外部访问时校验锁定状态
        if self._locked:
            raise AttributeError("属性已锁定，无法访问")
        return self.__dict__['name']

    @name.setter
    def name(self, value):
        caller_frame = inspect.currentframe().f_back
        if caller_frame.f_locals.get('self') is self:
            self.__dict__['name'] = value
            return
        # 外部修改时先检查锁定状态
        if self._locked:
            raise AttributeError("属性已锁定，无法修改")
        # 这里可加入层级加入前的属性规则校验
        if not isinstance(value, str) or len(value) == 0:
            raise ValueError("名称必须是非空字符串")
        self.__dict__['name'] = value

    def _add_to_hierarchy(self, parent):
        # 私有方法，仅允许工厂类或内部逻辑调用
        if not isinstance(parent, HierarchyNode):
            raise ValueError("父节点必须是HierarchyNode实例")
        # 规则校验通过后锁定属性
        self.__dict__['_locked'] = True
        self.__dict__['_parent'] = parent

class HierarchyFactory:
    @staticmethod
    def create_node(name, parent=None):
        node = HierarchyNode(name)
        if parent:
            # 工厂类直接调用私有方法完成层级加入与锁定
            node._add_to_hierarchy(parent)
        return node

方案说明： #

1. 内部访问跳过触发：类内部方法（如__init__、_add_to_hierarchy）直接操作__dict__，完全不触发@property的getter/setter，避免初始化时的逻辑干扰。
2. 外部访问触发校验：通过inspect判断调用来源，仅当外部访问时才检查锁定状态与属性规则。
3. 层级锁定控制：将_add_to_hierarchy设为私有，仅允许工厂类调用，确保只有工厂能完成节点的层级加入与属性锁定，避免用户提前修改属性破坏规则。

方案二：基于__getattribute__/__setattr__（满足「排除__init__的全局触发」） #

重写实例属性访问的魔法方法，通过判断调用上下文跳过__init__与内部方法的触发逻辑：

import inspect

class HierarchyNode:
    def __init__(self, name):
        # __init__内的访问会被自动跳过校验
        self.name = name
        self._locked = False
        self._parent = None

    def __getattribute__(self, attr_name):
        if attr_name == 'name':
            caller_frame = inspect.currentframe().f_back
            caller_func = caller_frame.f_code.co_name
            # 跳过__init__与类内部方法的调用
            if caller_func == '__init__' or caller_frame.f_locals.get('self') is self:
                return super().__getattribute__(attr_name)
            # 外部访问时检查锁定状态
            if self._locked:
                raise AttributeError("属性已锁定，无法访问")
        return super().__getattribute__(attr_name)

    def __setattr__(self, attr_name, value):
        if attr_name == 'name':
            caller_frame = inspect.currentframe().f_back
            caller_func = caller_frame.f_code.co_name
            if caller_func == '__init__' or caller_frame.f_locals.get('self') is self:
                super().__setattr__(attr_name, value)
                return
            # 外部修改时校验锁定与规则
            if self._locked:
                raise AttributeError("属性已锁定，无法修改")
            if not isinstance(value, str) or len(value) == 0:
                raise ValueError("名称必须是非空字符串")
        super().__setattr__(attr_name, value)

    def add_to_hierarchy(self, parent):
        if not isinstance(parent, HierarchyNode):
            raise ValueError("父节点类型错误")
        self._locked = True
        self._parent = parent

方案说明： #

• 重写__getattribute__和__setattr__，通过调用栈判断是否为__init__或内部方法调用，若是则直接执行原生逻辑，不触发校验。
• 外部访问时自动触发锁定检查与属性规则校验，满足「除__init__外所有访问触发」的需求。

关键注意点 #

• 栈帧判断依赖inspect模块，性能影响极小，适合大多数场景。
• 若要严格限制层级加入的权限，建议使用工厂类配合私有方法，避免用户直接调用锁定逻辑。
• 内部操作属性时，务必保持逻辑一致性，避免绕过规则的意外修改。

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