Question

从我到目前为止，装饰器适用于callables（函数和类）。想知道是否有办法将装饰器应用于字典？（事实上，它可以是任何数据结构）。我试图解决的问题如下：我有很多词典，有时可能有效或无效。

我想用装饰器标记它们，如骨架下方所示...：

class Data(object):

    def invalide(self):
        return False

    def valide(self, some_dict):
        return some_dict

@Data.invalide  
dict_1 = {...}

@Data.valide  
dict_2 = {...}

@Data.valide  
dict_3 = {...}
...
...
@Data.invalide
dict_n = {...}

...所以，当我致电some_function(dict_x)时，它会根据valide，invalide标记知道做一件事或另一件事。

-------------稍后--------------------

我最终实现了以下内容：

In [2]: class Data(object):
   ...:     
   ...:     @classmethod
   ...:     def valide(self, func):
   ...:         #print "Data is valide."
   ...:         return func()
   ...:     
   ...:     @classmethod
   ...:     def invalide(self, func):
   ...:         #print "Data is invalide."
   ...:         return False
   ...:     

In [3]: @Data.valide
   ...: def dict1():
   ...:     return {"a": 1, "b": 2, "c": 3}
   ...: 
   ...: @Data.invalide
   ...: def dict2():
   ...:     return {"d": 4, "e": 4, "f": 6}
   ...: 
   ...: def run_funct(some_dict):
   ...:     return some_dict
   ...: 

In [4]: print(run_funct(dict1))
   ...: print type(run_funct(dict1))
   ...: 
{'a': 1, 'c': 3, 'b': 2}
<type 'dict'>

In [5]: print(run_funct(dict2))
   ...: print type(run_funct(dict2))
   ...: 
False
<type 'bool'>

Answer 1

据我所知，

装饰器只能应用于callables（函数，类等）。

如果我在你的位置，我可能将逻辑分开来决定其自身功能中的有效/无效。

Answer 2

你可以用属性和装饰器拼凑一些东西：

def valid(func):
    return property(lambda self: func(self))
def invalid(func):
    return property(lambda self: False)

class A:
    @valid
    def dict1(self):
        return dict(a=4, b=5)
    @invalid
    def dict2(self):
        return dict(c=6, d=7)

用法将是：

a = A()
a.dict1
a.dict2

我不能说我会建议这样做，但它应该满足你的需求。

有没有办法将装饰器应用于Python数据结构？

-------------稍后--------------------

2 个答案: