带参数的 Python 描述符？

Question

长话短说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 相同的输出。谢谢!

Answer 1

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

由于您将 ['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