Python中能否让类属性仅对特定类实例可见并访问？

针对你提出的需求——让B类的部分属性仅对A类实例开放、禁止用户直接访问，这里提供几种Pythonic的优雅实现方式，替代不符合设计理念的私有属性方案：

方法1：使用描述符（Descriptor） #

描述符是Python原生的属性访问控制机制，我们可以通过它校验访问者的身份，只允许A类实例访问目标属性。

class RestrictedAccess:
    def __init__(self, internal_attr):
        self.internal_attr = internal_attr

    def __get__(self, instance, owner):
        # 检查调用者是否为A类实例
        import inspect
        caller_frame = inspect.currentframe().f_back
        caller_self = caller_frame.f_locals.get('self')
        if isinstance(caller_self, A):
            return instance.__dict__[self.internal_attr]
        raise AttributeError("该属性仅允许A实例访问")

    def __set__(self, instance, value):
        # 同样限制赋值权限
        import inspect
        caller_frame = inspect.currentframe().f_back
        caller_self = caller_frame.f_locals.get('self')
        if isinstance(caller_self, A):
            instance.__dict__[self.internal_attr] = value
        else:
            raise AttributeError("该属性仅允许A实例修改")

class B:
    # 对外暴露的受限属性，由描述符控制访问
    last_update = RestrictedAccess('_last_update')

    def __init__(self):
        self._last_update = "2024-05-20 10:00:00"

class A:
    def __init__(self):
        self.registered_bs = []

    def register_b(self, b_instance):
        if isinstance(b_instance, B):
            self.registered_bs.append(b_instance)

    def check_b_update(self, b_instance):
        return b_instance.last_update

# 测试
a = A()
b = B()
a.register_b(b)

# A实例正常访问
print(a.check_b_update(b))  # 输出：2024-05-20 10:00:00

# 用户直接访问报错
try:
    print(b.last_update)
except AttributeError as e:
    print(e)  # 输出：该属性仅允许A实例访问

方法2：嵌套类+实例绑定（仅允许所属A实例访问） #

如果需要更严格的限制——B实例的受限属性仅对注册它的那个A实例开放，可以通过嵌套类+闭包绑定A实例标识实现：

class A:
    def __init__(self):
        self.registered_bs = []
        self._instance_id = id(self)

    def create_b(self):
        # 在A实例方法内嵌套定义B，让B绑定当前A实例的标识
        class B:
            def __init__(self):
                self._status = "仅所属A实例可见"

            def _get_status(self, caller_id):
                if caller_id == self._instance_id:
                    return self._status
                raise AttributeError("该属性仅允许所属的A实例访问")

        b_instance = B()
        self.registered_bs.append(b_instance)
        return b_instance

    def get_b_status(self, b_instance):
        return b_instance._get_status(id(self))

# 测试
a1 = A()
b1 = a1.create_b()
a2 = A()

# 所属A实例正常访问
print(a1.get_b_status(b1))  # 输出：仅所属A实例可见

# 其他A实例或用户直接访问报错
try:
    print(a2.get_b_status(b1))
except AttributeError as e:
    print(e)  # 输出：该属性仅允许所属的A实例访问

方法3：令牌验证机制 #

给每个A实例生成唯一令牌，B实例仅响应持有正确令牌的访问请求：

import uuid

class B:
    def __init__(self):
        self._restricted_data = "仅持令牌的A实例可见"
        self._allowed_token = None

    def bind_token(self, token):
        self._allowed_token = token

    def __getattr__(self, name):
        if name == 'restricted_data':
            import inspect
            caller_frame = inspect.currentframe().f_back
            caller = caller_frame.f_locals.get('self')
            if hasattr(caller, '_token') and caller._token == self._allowed_token:
                return self._restricted_data
            raise AttributeError("无权限访问该属性")
        raise AttributeError(f"'B' object has no attribute '{name}'")

class A:
    def __init__(self):
        self.registered_bs = []
        self._token = uuid.uuid4()

    def register_b(self, b_instance):
        if isinstance(b_instance, B):
            b_instance.bind_token(self._token)
            self.registered_bs.append(b_instance)

    def fetch_b_data(self, b_instance):
        return b_instance.restricted_data

# 测试
a = A()
b = B()
a.register_b(b)

print(a.fetch_b_data(b))  # 输出：仅持令牌的A实例可见

try:
    print(b.restricted_data)
except AttributeError as e:
    print(e)  # 输出：无权限访问该属性

注意事项 #

Python是动态语言，不存在绝对的访问控制，以上方案都是约定式的权限隔离，能满足常规业务场景的需求，但无法完全阻止恶意用户通过反射等手段绕过限制。

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