很难让decorator在python中的类内工作

寄存器装饰器

首先,当使用decorator作为函数的寄存器时,一个好的选择是为decorator编写一个类,以便它可以用于注册和访问已注册的函数。

class RegisterDecorator(object):
    def __init__(self):
        self._register = {}

    def __getitem__(self, item):
        return self._register[item]

    def register(self, text):
        def wrapper(f):
            self._register[text] = f
            return f
        return wrapper

saying = RegisterDecorator()

@saying.register('hello')
def f():
    print('Hello World')

saying['hello']() # prints 'Hello World'

注册类中的方法

以上方法对注册方法有效。不过,它只会注册 未绑定的 方法。这意味着你必须通过 self 手动参数。

saying = Saying()

class PoliteModule(object):
    @saying.register("hi")
    def hi(self):
        print("hello there")

saying['hi'](PoliteModule()) # prints: 'hello there'

saying['hi']() # TypeError: hi() missing 1 required positional argument: 'self'

注册绑定方法

无法在类实例化时注册绑定方法,因为还不存在实例。您必须创建一个实例并注册其绑定方法。

saying = Saying()

class PoliteModule(object):
    def hi(self):
        print("hello there")

politeInstance = PoliteModule()

saying.register("hi")(politeInstance.hi)

saying["hi"]() # prints: hello there

你需要2次初始化。

在类初始化时,decorators应该用于 贴上 指定方法的名称。或者在类完全定义之后,它可以接收一个新的 mapping 属性将名称映射到方法名称。

一个成员初始化,每个成员都应该收到一个 映射 属性将名称映射到绑定方法。

我将使用基类和修饰符:

class PoliteBase(object):
    def __init__(self):
        """Initializes "polite" classes, meaning subclasses of PoliteBase

This initializer will be called by subclasse with no explicit __init__ method,
but any class with a __init__ method will have to call this one explicitely
for proper initialization"""
        cls = self.__class__              # process this and all subclasses
        if not hasattr(cls, "mappings"):  # add a mapping attribute TO THE CLASS if not
            cls.mappings = {}             #  present
            for m in cls.__dict__:        # and feed it with "annotated" methods and names
                o = getattr(cls, m)
                if callable(o) and hasattr(o, "_names"):    # only process methods
                    for name in o._names:                   #   with a _name attribute
                        cls.mappings[name] = m              # map the name to the method
                                                            #  name

        self.mappings = { k: getattr(self, m)         # now set the mapping for instances
                  for k,m in cls.mappings.iteritems() }  # mapping name to a bound method

如果子类没有定义 __init__ 方法,将使用基类1,但如果子类定义了基类1,则必须明确调用该基类。

def saying(name):
    """Decorator used in combination with "PoliteBase" subclasses

It just adds a _name attribute to the decorated method containing the associated
names. This attribute will later be processed at instance initialization time."""
    @functools.wraps(f)
    def wrapper(f):
        try:
            f._names.append(name)
        except Exception as e:
            f._names = [name]
        return f
    return wrapper

完成后,您可以定义礼貌类:

class politeClass(PoliteBase):
    def __init__(self):
        self.mapping = {}

    @saying("hi")
    def hi(self):
        print "hello there"

    @saying("thanks")
    @saying("gracias")
    def thanks(self):
        print "you're welcome"

obj = politeClass()
obj.mapping["hi"]()
obj.mapping["thanks"]()

我把你的 模块 对象,因为模块在python意义上是不同的(它是脚本文件本身)

这里的问题是你需要访问 self 追加 self.mapping ,并且装饰器(如前所述)无权访问 自己 对象,因为它在类定义期间甚至在创建实例之前运行。

你可以存储变量 mapping 在类级别而不是实例级别。然后,您可以让decorator向它所修饰的每个函数添加一个属性,然后使用类decorator搜索具有该属性的函数并将其添加到cls.mapping:

方法修饰符

def saying(text):
    def decorator(function):
        if hasattr(function,"mapping_name"):
            function.mapping_name.append(text)
        else:
            function.mapping_name=[text]
        return function
    return decorator

(此后,我在这里使用了一个列表,当您两次调用decorator(如“谢谢”、“gracias”示例)时,如果映射名只是一个字符串,它将被覆盖。)

类装饰器

def map_methods(cls):
    cls.mapping = {}
    for item in cls.__dict__.values():
        if hasattr(item, "mapping_name"):
            for x in item.mapping_name:
                cls.mapping[x] = item
    return cls

然后你必须用 map_methods 装饰工如下:

@map_methods
class politeModule(object):

    @saying("hi")
    def hi(self):
        print ("hello there")

    @saying("thanks")
    @saying("gracias")
    def thanks(self):
        print ("you're welcome")

(另请注意,我们不再想写 self.mapping=[] 所以我把你的头去掉了。

替代方法

或者,你可以使用一个元类来做这种事情,但是我认为更重要的问题是你为什么要这样做。尽管这样做可能是有原因的,但无论最初的问题是什么,可能都有更好的解决方法。

重要的注意事项

您将无法使用您在原始post中使用的方法调用函数,例如。 module.mapping["hi"]() . 注意 module.mapping["hi"] 返回一个函数,然后调用该函数,因此不存在将传递给第一个参数的对象 自己 ,所以你必须写 module.mapping["hi"](module) . 解决这个问题的一个办法是你可以写 初始化 如下:

def __init__(self):
    self.mapping = { k: functools.partial(m, self) for k,m in self.mapping.items() }

这意味着映射现在是一个实例变量,而不是一个类变量。您现在还可以使用 module.mapping[“嗨”]() 自从 functools.partial 绑定 自己 第一个论点。别忘了加上 import functools 在你剧本的顶端。