Skip to main content
 首页 » 编程设计

带参数的 Python 描述符

2024年10月24日13zhenyulu

长话短说 Python 2.7.5,当使用描述符作为装饰器时,有没有办法传入参数(给 __init__ 方法)? 或者 如何使用带参数的方法装饰器 ( as here ) 访问类实例的属性? -- 我认为这是不可能的,因此下面的重点是描述符......


长版

我有一类对象,具有不同的“类型”属性。基于实例的“类型”,我希望方法可用或不可用。我知道一种方法是创建多个类,但我试图在创建这些对象时不要有一堆 if/else 语句。例如,我有两个几乎相同的对象 A 和 B,除了对象 B 我不想让 get_start_date() 方法可用。所以本质上,我想要的是 A 和 B 都是 MyObjects 类的实例,但具有不同的“类型”属性。

type(A) == type(B) 
A.genus_type != B.genus_type 

我会使用 .genus_type 属性来区分哪些方法是允许的,哪些不是...

我在想我可以使用带有白名单的装饰器,比如:

def valid_for(whitelist): 
    def wrap(f): 
        def wrapper(*args, **kwargs): 
            return f(*args, **kwargs) 
    return wrapper 
return wrap 
 
class A(object): 
    @valid_for(['typeB']) 
    def do_something_cool(self): 
        print 'blah' 

但问题是我无法访问装饰器中的实际类实例,我可以在装饰器中测试实例类型属性。基于this SO question ,我想,“我可以使用描述符!”。

然后我尝试了:

class valid_for(object): 
    """ descriptor to check the type of an item, to see 
    if the method is valid for that type""" 
    def __init__(self, func): 
        self.f = func 
 
    def __get__(self, instance, owner): 
        def wrapper(*args): 
            return self.f(instance, *args) 
        return wrapper 

但后来我不知道如何将 ['typeB'] 参数传递给描述符...默认情况下,Python 将调用的方法作为参数传递给 __init__。我可以为每种类型创建硬编码描述符并嵌套它们,但我想知道我是否会遇到 this problem .假设我可以克服嵌套问题,那么做类似的事情似乎也不那么干净:

class A(object): 
    @valid_for_type_b 
    @valid_for_type_f 
    @valid_for_type_g 
    def do_something_cool(self): 
        print 'blah' 

做这样的事情只是让我的 func 等于列表 ['typeB']...

class valid_for(object): 
    """ descriptor to check the type of an item, to see 
    if the method is valid for that type""" 
    def __init__(self, func, *args): 
        self.f = func 
 
    def __get__(self, instance, owner): 
        def wrapper(*args): 
            return self.f(instance, *args) 
        return wrapper 
 
class A(object): 
    @valid_for(['typeB']) 
    def do_something_cool(self): 
        print 'blah' 

而且我的 func 不在 *args 列表中,所以我不能只做一个简单的参数交换 (*args是空的)。

我一直在寻找提示 here和 here ,但还没有找到任何看似干净或有效的解决方法。有没有一种干净的方法可以做到这一点,还是我必须使用多个类并混合使用各种方法?或者,现在我倾向于一个检查的实例方法,但它似乎不那么干净和可重用......

class A(object): 
    def _valid_for(self, whitelist): 
        if self.genus_type not in whitelist: 
            raise Exception 
 
    def do_something_cool(self): 
        self._valid_for(['foo']) 
        print 'blah' 

我正在使用 Python 2.7.5。


更新 1

根据评论中的建议,我尝试了:

def valid_for2(whitelist): 
    def wrap(f): 
        def wrapper(*args, **kwargs): 
            import pdb 
            pdb.set_trace() 
            print args[0].genus_type 
            return f(*args, **kwargs) 
        return wrapper 
    return wrap 

但是此时,args[0]。只返回参数:

(Pdb) args[0] 
args = (<FormRecord object at 0x112f824d0>,) 
kwargs = {} 
(Pdb) args[0].genus_type 
args = (<FormRecord object at 0x112f824d0>,) 
kwargs = {} 

但是,按照建议使用 functools 确实有效 - 所以我会奖励答案。 functools 中似乎有一些黑魔法可以让参数进入?


更新 2

因此进一步研究 jonrsharpe 的建议,他的方法似乎也有效,但我必须明确使用 self 而不是 args[0]。不确定为什么行为不同......

def valid_for2(whitelist): 
    def wrap(f): 
        def wrapper(self, *args, **kwargs): 
            print self.genus_type 
            return f(*args, **kwargs) 
        return wrapper 
    return wrap 

产生与 functools 相同的输出。 谢谢!

请您参考如下方法:

如果我没看错你的情况,你要找的是a closure -- 一个可以引用的函数 外部函数的本地命名空间。

由于您将 ['typeB'] 传递给 valid_for,如

@valid_for(['typeB']) 

我们应该使 valid_for 成为返回装饰器的函数。 装饰器依次接受一个函数(新生方法)作为输入并返回另一个(包装器)函数。

在wrapper下面是一个闭包,它可以访问typelist的值 在运行时在其体内。


import functools 
def valid_for(typelist): 
    def decorator(func): 
        @functools.wraps(func) 
        def wrapper(self, *args): 
            if self.genus_type in typelist: 
                return func(self, *args) 
            else: 
                # handle this case 
                raise NotImplementedError( 
                    '{} not in {}'.format(self.genus_type, typelist)) 
        return wrapper 
    return decorator 
 
class A(object): 
    def __init__(self): 
        self.genus_type = 'typeA' 
    @valid_for(['typeB']) 
    def do_something_cool(self): 
        print 'blah' 
 
a = A() 
try: 
    a.do_something_cool() 
except NotImplementedError as err: 
    print(err) 
    # typeA not in ['typeB'] 
 
a.genus_type = 'typeB' 
a.do_something_cool() 
# blah