如何在Python中创建参数依赖类：参数相等则类对象相等？

基础场景：简单动态类的缓存实现 #

你给出的基础示例中，每次调用create_class(3)都会生成全新的Bar类，因此a==b返回False。核心解决思路是缓存相同参数对应的类实例，用functools.lru_cache装饰器即可实现：

from functools import lru_cache

@lru_cache(maxsize=None)
def create_class(n):
    class Bar:
        nn = n
    return Bar

a = create_class(3)
b = create_class(3)
print(a == b)  # 输出True

lru_cache会记录相同参数n对应的Bar类，后续调用直接返回缓存的类对象，自然满足相等性要求。

进阶场景：带嵌套继承的动态类实现 #

你尝试的Foo类嵌套内部类场景中，每次实例化Foo(n)都会重新定义Bar和Barr类，哪怕n相同，这些内部类仍是不同对象。解决方法是把内部类的生成逻辑抽离为带缓存的独立函数：

from functools import lru_cache

@lru_cache(maxsize=None)
def _create_bar(n):
    class Bar:
        nn = n
        def __init__(self, m):
            print(f"This uses n={Bar.nn} and m={m} in funny ways")
    return Bar

@lru_cache(maxsize=None)
def _create_barr(n):
    Bar = _create_bar(n)
    class Barr(Bar):
        nnn = n + 1
        def asd(self):
            print(f"I have inheritance too {Bar.nn} {Barr.nnn}")
    return Barr

class Foo:
    def __init__(self, n):
        self.n = n
        self.B = _create_bar(n)
        self.BB = _create_barr(n)
    
    def __eq__(self, other):
        return type(self) == type(other) and self.n == other.n

# 测试验证
ap = Foo(3)
a = Foo(3)
print(ap.B == a.B)  # 输出True
print(ap.BB == a.BB)  # 输出True

将内部类生成逻辑放到带缓存的函数后，相同n会返回同一个类对象，同时保留了原有的继承关系和功能。

复杂参数的处理方案 #

如果参数是复杂对象，只要该对象可哈希（实现__hash__和__eq__方法），lru_cache就能正常工作。若复杂对象默认不可哈希，可自定义哈希逻辑，基于对象的关键属性生成哈希值：

class ComplexParam:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __eq__(self, other):
        return isinstance(other, ComplexParam) and self.x == other.x and self.y == other.y
    
    def __hash__(self):
        return hash((self.x, self.y))

# 之后即可用ComplexParam实例作为参数传入带缓存的类生成函数

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