Python类私有属性受限访问实现方案的有效性及优化问询

我希望将私有属性的访问权限限制在选定方法范围内，即不希望公有类包含私有属性，因此需要单独的类来存储这些属性。但仅分离公有类和私有类无法直接实现访问控制，需自行绑定二者。基于此，我实现了一个可运行的原型代码：

基础代码 #

# Auto-binding of private classes to public classes.
class RemoteMeta(type):

    # Access to private classes via public class-names.
    _classes = { }

    def __new__(cls, name, bases, namespace, **kwargs):
        rv = type.__new__(cls, name, bases, namespace, **kwargs)

        if bases[0] is not object: # Ignore 'Remote' class.

            # Access to private class-instances via public class-instances.
            rv._instances = { }

            # Add private class reference.
            cls._classes[name[1:]] = rv

        return rv

    def __getattr__(cls, name):
        # Since attribute is not present in private class,
        # look for it in public class.
        return getattr(cls._cls, name)

# Auto-binding of public instances to private instances.
# Auto-binding of private instances to public instances.
class Remote(object, metaclass=RemoteMeta):

    def __new__(cls, inst, *args, **kwargs):

        if cls is Remote:
            detail = "'{}' class is not meant to be used directly".format(cls.__name__)
            raise TypeError(detail)

        v = object.__new__(cls)

        # ???
        v.__init__(*args, **kwargs)

        # Access to public instance from private instance.
        v._self = inst

        # Add private instance reference.
        cls._instances[inst] = v

    def __getattr__(self, name):
        # Since attribute is not present in private instance,
        # look for it in public instance.
        return getattr(self._self, name)

# Auto-binding of public classes to private classes.
class PublicMeta(type):
    def __new__(cls, name, bases, namespace, **kwargs):
        rv = type.__new__(cls, name, bases, namespace, **kwargs)

        if bases[0] is not object: # Ignore 'Public' class.

            # Access to public class from private class.
            Remote._classes[name]._cls = rv

        return rv

# Auto-creating of private instances for each new public instance.
class Public(object, metaclass=PublicMeta):

    def __new__(cls, *args, **kwargs):
        rv = object.__new__(cls)

        if cls is Public:
            detail = "'{}' class is not meant to be used directly".format(cls.__name__)
            raise TypeError(detail)

        # Create private instance.
        Remote._classes[cls.__name__](rv, *args, **kwargs)

        return rv

描述符代码 #

class RemoteClassMethod:
    [...]
            return self.method(
                Remote._classes[owner.__name__],
                *args, **kwargs
            )
    [...]

class RemoteInstanceMethod:
    [...]
            return self.method(
                Remote._classes[owner.__name__]._instances[inst],
                *args, **kwargs
            )
    [...]

class RemoteProperty:
    [...]
        return self.fget(
            Remote._classes[owner.__name__]._instances[inst]
        )
    [...]

现询问：上述代码是否为实现该需求的有效方式？是否存在严重缺陷？是否有更优的实现方案？

一、是否为有效实现方式？ #

你的代码确实能实现核心需求：将私有属性隔离在单独的Remote子类中，通过元类和描述符完成公有类与私有类的自动绑定，让选定方法能访问私有属性，同时公有类本身不持有这些属性。从功能层面看，这个原型是可运行且达到了设计目标的。

二、存在的严重缺陷 #

• 内存泄漏风险：RemoteMeta._classes和Remote._instances用普通字典持有类和实例的强引用，即使公有实例被销毁，私有实例也会因为被字典引用而无法被垃圾回收，长期运行会导致内存占用持续增长。
• 命名依赖脆弱：RemoteMeta中通过name[1:]关联公有类和私有类（假设私有类以_开头），这种硬编码的命名约定一旦被打破，整个绑定逻辑就会失效，且错误排查难度大。
• 线程安全问题：全局的_classes和_instances字典没有加锁，多线程环境下创建实例或访问类属性时，可能出现竞态条件，导致数据不一致。
• 调试与可读性差：属性查找通过__getattr__跨类转发，加上元类的隐式绑定逻辑，当出现属性访问错误时，栈追踪会非常复杂；同时整个架构的隐式规则太多，新接手的开发者需要花费大量时间理解绑定逻辑。
• 扩展性不足：描述符类直接依赖Remote._classes全局字典，后续如果要修改绑定逻辑，需要改动多个地方，违反开闭原则。

三、更优实现方案 #

方案1：组合模式+闭包封装私有状态 #

放弃元类的隐式绑定，直接在公有类中持有私有实例，但通过闭包限制只有指定方法能访问私有实例的属性：

class PrivateData:
    def __init__(self, value):
        self._secret = value

class PublicAPI:
    def __init__(self, value):
        self.__private = PrivateData(value)
        
        # 仅暴露允许访问私有属性的方法
        def get_secret():
            return self.__private._secret
        
        self.get_secret = get_secret

# 使用示例
api = PublicAPI("my secret")
print(api.get_secret())  # 正常访问
# print(api.__private._secret)  # 报错，无法直接访问私有实例

优点：逻辑直观，无内存泄漏风险，线程安全，调试简单；缺点：私有方法的定义需要手动封装，无法像类方法那样自然继承。

方案2：__slots__+私有属性命名规范 #

利用Python原生特性，通过__slots__限制公有类的属性，结合双下划线命名的私有属性（会被名字修饰），再通过类内部方法封装访问：

class PublicAPI:
    __slots__ = ("__secret",)  # 限制只能有这个私有属性
    def __init__(self, value):
        self.__secret = value
    
    def get_secret(self):
        return self.__secret
    
    def set_secret(self, value):
        # 可在此添加访问控制逻辑
        if isinstance(value, str):
            self.__secret = value
        else:
            raise ValueError("Secret must be string")

# 使用示例
api = PublicAPI("my secret")
print(api.get_secret())
# print(api.__secret)  # 报错，无法直接访问
# print(api._PublicAPI__secret)  # 虽能通过名字修饰访问，但属于非常规操作，可通过代码规范约束

优点：实现简单，无需复杂的元类和描述符；缺点：无法完全阻止通过名字修饰访问私有属性，但符合Python"我们都是成年人"的设计哲学，通过代码规范即可约束。

方案3：改进原有架构（弱引用+显式绑定） #

保留你的核心架构，但解决内存泄漏和线程安全问题：

1. 用weakref.WeakKeyDictionary替代普通字典存储_instances，避免内存泄漏；
2. 对全局字典的访问加锁，保证线程安全；
3. 用类装饰器显式关联公有类和私有类，去掉硬编码的命名约定。

简化示例：

import weakref
import threading

class RemoteMeta(type):
    _classes = {}
    _lock = threading.Lock()

    def __new__(cls, name, bases, namespace, **kwargs):
        rv = super().__new__(cls, name, bases, namespace, **kwargs)
        if bases[0] is not object:
            rv._instances = weakref.WeakKeyDictionary()
            with cls._lock:
                cls._classes[name] = rv
        return rv

# 用装饰器显式关联公有类和私有类
def bind_remote(remote_cls):
    def decorator(public_cls):
        with RemoteMeta._lock:
            RemoteMeta._classes[remote_cls.__name__]._cls = public_cls
        return public_cls
    return decorator

# 使用示例
class _MyRemote(Remote):
    def __init__(self, inst, value):
        self._secret = value

@bind_remote(_MyRemote)
class MyPublic(Public):
    def __init__(self, value):
        super().__init__(value)
    
    def get_secret(self):
        return self._secret

优点：保留原有架构的隔离优势，同时解决了核心缺陷；缺点：复杂度仍高于前两种方案，适合需要严格隔离私有状态的场景。

内容的提问来源于stack exchange，提问作者Marcin Tamiński