Python如何限制类构造函数仅能从指定工厂方法调用？

我理解你的需求：你想强制用户通过Factory类方法来创建Foo实例，同时希望阻止直接调用__init__（或者说直接实例化Foo()）。你之前尝试用inspect模块检测调用来源，但因为类方法的绑定实例每次获取都会生成新对象，导致ID对比失效，这确实是个常见的陷阱。

下面给你几个可行的实现方案，从简单到彻底的都有：

方案1：检查调用栈的代码对象（修复你的原始思路） #

你之前的问题出在对比绑定方法的ID上——每次访问Foo.Factory都会生成一个新的绑定方法实例，所以它们的ID永远不一样。正确的做法是对比函数的代码对象，因为每个函数的__code__属性是唯一的。

修改你的代码如下：

import inspect

class Foo():
    def __init__(self):
        # 获取Factory方法的代码对象
        allowed_code = Foo.Factory.__func__.__code__
        # 获取调用__init__的栈帧的代码对象
        caller_frame = inspect.currentframe().f_back
        caller_code = caller_frame.f_code
        
        if caller_code is not allowed_code:
            raise RuntimeError("Foo只能通过Foo.Factory()方法实例化")
        
        print("Foo实例初始化完成")

    @classmethod
    def Factory(cls):
        return Foo()

# 正常调用
Foo.Factory()
# 直接调用会报错
# Foo()

这个方案的核心是：不管绑定方法怎么变，Factory函数本身的代码对象是固定的，对比这个就能准确判断调用来源是否合法。

方案2：使用私有构造方法（简单防误触） #

如果你的主要目的是防止误操作而非彻底禁止（毕竟Python没有真正的私有方法），可以把__new__设为私有命名（双下划线开头），然后在Factory内部调用：

class Foo():
    def __new__(cls):
        # 私有构造方法，外部直接调用会触发访问限制
        return super().__new__(cls)

    def __init__(self):
        print("Foo实例初始化完成")

    @classmethod
    def Factory(cls):
        instance = cls.__new__(cls)  # 内部调用私有构造方法
        instance.__init__()
        return instance

# 正常调用
instance = Foo.Factory()
# 直接调用Foo()会报错：TypeError: cannot create 'Foo' instances
# Foo()

这个方式利用Python的名字改写机制，能有效阻止大部分误操作，但熟悉Python机制的开发者仍可通过_Foo__new__绕过，适合对安全性要求不极高的场景。

方案3：使用元类（最彻底的拦截） #

如果你想彻底阻止任何非Factory途径的实例化，可以用元类拦截类的__call__方法（这是Python实例化对象的入口）：

import inspect

class FactoryOnlyMeta(type):
    def __call__(cls, *args, **kwargs):
        # 检查调用来源是否是当前类的Factory方法
        caller_frame = inspect.currentframe().f_back
        caller_code = caller_frame.f_code
        
        # 验证两个条件：调用者函数名是Factory，且调用时的cls参数是当前类
        if caller_code.co_name != "Factory" or caller_frame.f_locals.get("cls") != cls:
            raise RuntimeError(f"{cls.__name__}只能通过{cls.__name__}.Factory()实例化")
        
        # 允许实例化
        return super().__call__(*args, **kwargs)

class Foo(metaclass=FactoryOnlyMeta):
    def __init__(self):
        print("Foo实例初始化完成")

    @classmethod
    def Factory(cls):
        return cls()

# 正常调用
Foo.Factory()
# 直接调用Foo()会报错
# Foo()
# 子类如果继承Foo，也会自动继承这个限制，除非子类重写Factory方法

这个方案最可靠，因为它直接拦截了类的实例化过程，任何绕过Factory的尝试都会被阻止，甚至包括子类的非法实例化（除非子类重写元类或Factory方法）。

补充说明 #

• 关于inspect模块的栈帧检测：虽然依赖栈帧在某些极端场景（比如异步函数、多层装饰器嵌套）可能会有问题，但在常规的同步代码中完全可靠。
• Python的"私有"机制：双下划线开头的名字会被名字改写（name mangling），但这只是一种约定，并非真正的访问限制，所以如果需要彻底禁止，元类是更好的选择。

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