Question

TL; DR Python 2.7.5，当使用描述符作为装饰器时，有没有办法传入参数（到__init__方法）？要么如何使用带参数（as here）的方法装饰器访问类实例的属性？ - 我认为这是不可能的，因此下面的重点是描述符...

长版

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

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，我想，＆＃34;我可以使用描述符！＆＃34;。

所以我接着尝试了：

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]。只返回args：

(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

如果我理解你的情况，你正在寻找的是a closure - 一个可以参考的功能外部函数的本地命名空间。

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

@valid_for(['typeB'])

我们应该让valid_for一个函数返回一个装饰器。装饰器接受一个函数（新生方法）作为输入并返回另一个（wrapper）函数。

以下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

带参数的Python描述符？

1 个答案: