Python的结构型设计模型之修饰器模式

一般来说，“修饰器”是个单参数的函数，其参也是函数。框架经常使用修饰器把用户所编写的函数集成进来。
白话说就是在一个函数定义的前一行，写上修饰器，就代表此函数具有修饰器的功能。
我现在用的最多的就是 flask 框架，有的函数其修饰器，可以设置成只有已登录用户进行操作。框架里面的路由视图多了，这样的一个修饰器起到了极大的作用。

以下代码依次对修饰器进行举例：

def float_args_and_return(function):    @functools.wraps(function)    def wapper(*args, **kwargs):        args = [float(arg) for arg in args]        return float(function(*args, **kwargs))    return wapper()@float_args_and_returndef mean1(first, second, *rest):    numbers = (first, second) + rest    return sum(numbers) / len(numbers)def mean2(first, second, *rest):    numbers = (first, second) + rest    return sum(numbers) / len(numbers)mean2 = float_args_and_return(mean2)

这个是无参数化的修饰器，意思就是 @XXXXX 这里的 XXXX 是没有参数的，直接对 mean 进行修饰。
mean2 就是对修饰器进行一次讲解，两个是等价的。方便大家理解。

def statically_typed(return_type=None, *item):#     因 python3.x 和 2.x 版本还是有些许差别#     这里带有参数的修饰器只介绍逻辑思路#     1.先创建修饰器工厂#     2.由工厂创建包装函数    def decorator(function):        @functools.wraps(function)        def wrapper(*args, **kwargs):            dosomething()            result = dosomething            return result        return wrapper    return decorator@statically_typed(return_type=str, str, str)def make_tagged(text, tag):    return "<{0}>{1}</{0}>".format(tag, text)@statically_typed(str, int, str)def repeat(what, count, separator):    return ((what + separator) * count)[:-len(separator)]

参数化的修饰器，能复杂一点，如上所说，得先创建一个 decorator 的修饰器工厂，由工厂来创建修饰器。
值得注意一点：
decorator 修饰器工厂会返回 wrapper() ，wrapper() 函数就是来捕获其外围函数的状态，就是 types 和 return_type 关键字参数。
能够捕获状态的函数或方法就叫做“闭包”。

@application.post("/mailinglists/add")@Web.ensure_logged_indef person_add_submit(username):    name = bottle.request.forms.get("name")    try:        id = Data.MailingLists.add(name)        bottle.redirect("/mailinglists/view")    except Data.Sql.Error as err:        return bottle.mako_template("error", url="/mailinglists/add", text="Add mailinglist", message=str(err))def ensuer_logged_in(function):    @functools.wraps(function)    def wrapper(*args, **kwargs):        username = bottle.request.get_cookie(COOKIE, sercet=sercet(bottle.request))        if username is not None:            kwargs["username"] = username            return function(*args, **kwargs)        bottle.redirect("/login")    return wrapper

bottle框架的例子，确认是否登录的修饰器，和我一开始说的如出一辙，大概就是这么回事。
这个修饰器，用 cookie 来判断用户是否登录，登录的话，就默认用户存在，否则返回登录界面。

类修饰器，就是对一个类里面的属性进行修饰。因大量重复的 getter 和 setter，类修饰器慢慢呈现出来。

def ensuer(name, validate, doc=None):    def decorator(Class):        privateName = "__" + name        def getter(self):            return getattr(self, privateName)        def setter(self, value):            validate(name, value)            return setattr(self, privateName, value)        setattr(Class, name, property(getter, setter, doc=doc))        return Class    return decoratordef is_non_empty_str(name, value):    if not isinstance(value, str):        raise ValueError("Type must str, not {}".format(name))    if not bool(value):        raise ValueError("{} may not be empty".format(name))def is_in_range(minimum=None, maximum=None):    assert minimum is not None or maximum is not None    def is_in_range(name, value):        if not isinstance(value, numbers.Number):            raise ValueError("{} must be a number".format(name))        if minimum is not None and value < minimum:            raise ValueError("{} is too small {}".format(name, value))        if maximum is not None and value > maximum:            raise ValueError("{} is too big {}".format(name, value))    return is_in_range()@ensuer("title", is_non_empty_str)@ensuer("price", is_in_range(1, 10000))@ensuer("quantity", is_in_range(0, 1000000))class Book:    def __init__(self, title, price, quantity):        self.title = title        self.price = price        self.quantity = quantity    @property    def value(self):        return self.price * self.quantity

一个 book 有三个属性，三个修饰器可以对三个属性进行控制操作。
而这样看是不是觉得 ensuer 太多了，可以简化成一个修饰器吗？

def db_ensure(Class):    def make_property(name, attribute):        privateName = "__" + name        def getter(self):            return getattr(self, privateName)        def setter(self, value):            attribute.validate(name, value)            setattr(self, privateName, value)        return property(getter, setter, doc=attribute.doc)    for name, attribute in Class.__dict__.items():        if isinstance(attribute, Ensure):            setattr(Class, name, make_property(name, attribute))    return Classclass Ensure:    def __init__(self, validate, doc=None):        self.validate = validate        self.doc = doc@db_ensureclass book:    title = Ensure(is_non_empty_str)    price = Ensure(is_in_range(1, 10000))    quantity = Ensure(is_in_range(1, 100000))    def __init__(self, title, price, quantity):        self.title = title        self.price = price        self.quantity = quantity    @property    def value(self):        return self.price * self.quantity

关键在于 attribute 和 Ensuer，大概意思就是把 Ensuer 当作属性的方法

总的来说，修饰器就是能简化，方便，改善程序。如书上讲“是 Python 中易用且强大的功能”。而我认为要灵活使用修饰器，必须学会 Python 在面向对象方面的基础。