文档章节

设计模式之:理解 Python 中的装饰器

大数据之路
 大数据之路
发布于 2013/07/22 03:39
字数 2416
阅读 887
收藏 27

1、问题

文章先由stackoverflow上面的一个问题引起吧,如果使用如下的代码: 

@makebold  
@makeitalic  
def say():  
    return "Hello"

打印出如下的输出: 

<b><i>Hello<i></b>

你会怎么做?最后给出的答案是: 

def makebold(fn):  
    def wrapped():  
        return "<b>" + fn() + "</b>"  
    return wrapped  
   
def makeitalic(fn):  
    def wrapped():  
        return "<i>" + fn() + "</i>"  
    return wrapped  
  
@makebold  
@makeitalic  
def hello():  
    return "hello world"  
   
print hello() ## 返回 <b><i>hello world</i></b>

现在我们来看看如何从一些最基础的方式来理解Python的装饰器。英文讨论参考  Here

1.1. 需求是怎么来的? 

装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。

装饰器的定义很是抽象,我们来看一个小例子。 

def foo():  
    print 'in foo()'  
foo()

这是一个很无聊的函数没错。但是突然有一个更无聊的人,我们称呼他为B君,说我想看看执行这个函数用了多长时间,好吧,那么我们可以这样做: 

import time  
def foo():  
    start = time.clock()  
    print 'in foo()'  
    end = time.clock()  
    print 'used:', end - start  
   
foo()

很好,功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了,他对另一个叫foo2的函数产生了更浓厚的兴趣。 

怎么办呢?如果把以上新增加的代码复制到foo2里,这就犯了大忌了~复制什么的难道不是最讨厌了么!而且,如果B君继续看了其他的函数呢? 

1.2. 以不变应万变,是变也  

还记得吗,函数在Python中是一等公民,那么我们可以考虑重新定义一个函数timeit,将foo的引用传递给他,然后在timeit中调用foo并进行计时,这样,我们就达到了不改动foo定义的目的,而且,不论B君看了多少个函数,我们都不用去修改函数定义了! 

import time  
   
def foo():  
    print 'in foo()'  
   
def timeit(func):  
    start = time.clock()  
    func()  
    end =time.clock()  
    print 'used:', end - start  
   
timeit(foo)

看起来逻辑上并没有问题,一切都很美好并且运作正常!……等等,我们似乎修改了调用部分的代码。原本我们是这样调用的:foo(),修改以后变成了:timeit(foo)。这样的话,如果foo在N处都被调用了,你就不得不去修改这N处的代码。或者更极端的,考虑其中某处调用的代码无法修改这个情况,比如:这个函数是你交给别人使用的。 

1.3. 最大限度地少改动!  

既然如此,我们就来想想办法不修改调用的代码;如果不修改调用代码,也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo,但是timeit似乎带有一个参数……想办法把参数统一吧!如果timeit(foo)不是直接产生调用效果,而是返回一个与foo参数列表一致的函数的话……就很好办了,将timeit(foo)的返回值赋值给foo,然后,调用foo()的代码完全不用修改! 

#-*- coding: UTF-8 -*-  
import time  
   
def foo():  
    print 'in foo()'  
   
# 定义一个计时器,传入一个,并返回另一个附加了计时功能的方法  
def timeit(func):  
       
    # 定义一个内嵌的包装函数,给传入的函数加上计时功能的包装  
    def wrapper():  
        start = time.clock()  
        func()  
        end =time.clock()  
        print 'used:', end - start  
       
    # 将包装后的函数返回  
    return wrapper  
   
foo = timeit(foo)  
foo()

这样,一个简易的计时器就做好了!我们只需要在定义foo以后调用foo之前,加上foo = timeit(foo),就可以达到计时的目的,这也就是装饰器的概念,看起来像是foo被timeit装饰了。在在这个例子中,函数进入和退出时需要计时,这被称为一个横切面(Aspect),这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言,像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里,能减少大量重复代码。面向切面编程还有相当多的术语,这里就不多做介绍,感兴趣的话可以去找找相关的资料。 
这个例子仅用于演示,并没有考虑foo带有参数和有返回值的情况,完善它的重任就交给你了 :) 

上面这段代码看起来似乎已经不能再精简了,Python于是提供了一个语法糖来降低字符输入量。 

import time  
   
def timeit(func):  
    def wrapper():  
        start = time.clock()  
        func()  
        end =time.clock()  
        print 'used:', end - start  
    return wrapper  
  
@timeit  
def foo():  
    print 'in foo()'  
   
foo()

重点关注第11行的@timeit,在定义上加上这一行与另外写foo = timeit(foo)完全等价,千万不要以为@有另外的魔力。除了字符输入少了一些,还有一个额外的好处:这样看上去更有装饰器的感觉。 

1.4 最后回答前面提到的问题: 

# 装饰器makebold用于转换为粗体
def makebold(fn):
    # 结果返回该函数
    def wrapper():
        # 插入一些执行前后的代码
        return "<b>" + fn() + "</b>"
    return wrapper
 
# 装饰器makeitalic用于转换为斜体
def makeitalic(fn):
    # 结果返回该函数
    def wrapper():
        # 插入一些执行前后的代码
        return "<i>" + fn() + "</i>"
    return wrapper
# 注意顺序 
@makebold
@makeitalic
def say():
    return "hello"
 
print say()
#输出: <b><i>hello</i></b>
 
# 等同于
def say():
    return "hello"
say = makebold(makeitalic(say))
 
print say()
#输出: <b><i>hello</i></b>

2、装饰器的种类

2.1 无参数装饰器

def deco(func):  
    print func  
    return func  
@deco  
def foo():pass  
foo()

第一个函数deco是装饰函数,它的参数就是被装饰的函数对象。我们可以在deco函数内对传入的函数对象做一番“装饰”,然后返回这个对象(记住一定要返回 ,不然外面调用foo的地方将会无函数可用。实际上此时foo=deco(foo))

我写了个小例子,检查函数有没有说明文档:

def deco_functionNeedDoc(func):  
    if func.__doc__ == None :  
        print func, "has no __doc__, it's a bad habit."  
    else:  
        print func, ':', func.__doc__, '.'  
    return func  
@deco_functionNeedDoc  
def f():  
    print 'f() Do something'  
@deco_functionNeedDoc  
def g():  
    'I have a __doc__'  
    print 'g() Do something'  
f()  
g()

2.2 有参数装饰器

def decomaker(arg):  
    '通常对arg会有一定的要求'  
    """由于有参数的decorator函数在调用时只会使用应用时的参数  
       而不接收被装饰的函数做为参数,所以必须在其内部再创建  
       一个函数  
    """  
    def newDeco(func):    #定义一个新的decorator函数  
        print func, arg  
        return func  
    return newDeco  
@decomaker(deco_args)  
def foo():pass  
foo()

第一个函数decomaker是装饰函数,它的参数是用来加强“加强装饰”的。由于此函数并非被装饰的函数对象,所以在内部必须至少创建一个接受被装饰函数的函数,然后返回这个对象(实际上此时foo=decomaker(arg)(foo))

这个我还真想不出什么好例子,还是见识少啊,只好借用同步锁的例子了:

def synchronized(lock):  
    """锁同步装饰方法 
    !lock必须实现了acquire和release方法 
    """  
    def sync_with_lock(func):  
        def new_func(*args, **kwargs):  
            lock.acquire()  
            try:  
                return func(*args, **kwargs)  
            finally:  
                lock.release()  
        new_func.func_name = func.func_name  
        new_func.__doc__ = func.__doc__  
        return new_func  
    return sync_with_lock  
@synchronized(__locker)  
def update(data):  
"""更新计划任务"""  
    tasks = self.get_tasks()  
    delete_task = None  
    for task in tasks:  
        if task[PLANTASK.ID] == data[PLANTASK.ID]:  
            tasks.insert(tasks.index(task), data)  
            tasks.remove(task)  
            delete_task = task  
    r, msg = self._refresh(tasks, delete_task)  
    return r, msg, data[PLANTASK.ID]

调用时还是updae(data)。

 同时还可以将多个装饰器组合 使用,注意调用顺序:

@synchronized(__locker)  
@deco_functionNeedDoc  
def f():  
    print 'f() Do something'

2.3 内置的装饰器

内置的装饰器有三个,分别是staticmethod、classmethod和property,作用分别是把类中定义的实例方法变成静态方法、类方法和类属性。由于模块里可以定义函数,所以静态方法和类方法的用处并不是太多,除非你想要完全的面向对象编程。而属性也不是不可或缺的,Java没有属性也一样活得很滋润。从我个人的Python经验来看,我没有使用过property,使用staticmethod和classmethod的频率也非常低。

具体请参考: http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html


3、REF:

1、可爱的 Python: Decorator 简化元编程

http://www.ibm.com/developerworks/cn/linux/l-cpdecor.html

2、Python的装饰器

http://jnotes.googlecode.com/svn/trunk/Notes/NotesOnPythonLearning/Python_decorator.html

3、Python装饰器学习

http://blog.csdn.net/thy38/article/details/4471421

4、通过 Python 装饰器实现DRY(不重复代码)原则

http://www.oschina.net/translate/dry-principles-through-python-decorators

5、http://simeonfranklin.com/blog/2012/jul/1/python-decorators-in-12-steps/

6、python-patterns:python 设计模式

https://github.com/faif/python-patterns

7、写给Python初学者的设计模式入门

http://blog.sae.sina.com.cn/archives/3151

8、Python修饰器的函数式编程

http://coolshell.cn/articles/11265.html

9、Python高级特性(2):Closures、Decorators和functools

http://blog.jobbole.com/66895/

10、python装饰器详解

http://blog.segmentfault.com/xuelang/1190000000632572

11、写给Python初学者的设计模式入门

http://python.jobbole.com/62023/

12、这不是魔法:Flask decorator 和 @app.route(1)

http://python.jobbole.com/80956/

13、这不是魔法:Flask和@app.route(2)

http://python.jobbole.com/80993/

14、Things which aren't magic - Flask and @app.route - Part 2

http://ains.co/blog/things-which-arent-magic-flask-part-2.html

15、Python中备忘功能和装饰器

http://python.jobbole.com/81107/

16、Python中使用内层函数的好处

http://python.jobbole.com/81679/

17、12步轻松搞定python装饰器

http://python.jobbole.com/81683/

本文转载自:http://hmw.iteye.com/blog/1510673

大数据之路
粉丝 1588
博文 516
码字总数 340320
作品 0
武汉
架构师
私信 提问
写给 Python 初学者的设计模式入门

有没有想过设计模式到底是什么?通过本文可以看到设计模式为什么这么重要,通过几个Python的示例展示为什么需要设计模式,以及如何使用。 设计模式是什么? 设计模式是经过总结、优化的,对我...

oschina
2014/03/12
5.3K
13
Android 设计模式-装饰模式(Decorator Pattern)

定义 饰模式指的是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。 UML结构图 Component:组件对象接口 Concre...

Code猎人
2018/05/10
0
0
大意了,这几道Python面试题没有答对,Python面试题No13

第1题: Python如何爬取 HTTPS 网站? 这类问题属于简单类问题 在使用 requests 前加入:requests.packages.urllib3.disable_warnings()。 为 requests 添加 verify=False 参数 导入ssl模块 ...

梦想橡皮擦
05/21
0
0
Python新式类 new init 单例模式与作用域(四)

1 新式类与旧式类 新式类拥有经典类的全部特性之外,还有一些新的特性,比如 发生变化,新增了静态方法,python3目前都采用新式类,新式类是广度优先,旧式类是深度优先 (2)类的方法 静态方法 类方...

善良小郎君
2018/06/18
0
0
python 与设计模式 ——工厂与装饰者

python 与设计模式第二篇 添加了test.py,里面的单元测试有使用的方法。 源码地址:[http://git.oschina.net/duoduo3_69/python_design_pattern][1] git checkout v002(这个版本与此篇博客相符...

duoduo3_69
2013/11/27
0
1

没有更多内容

加载失败,请刷新页面

加载更多

两数的最大公约数

hello,复习一下数学知识! 最大公因数,也称最大公约数、最大公因子,指两个或多个整数共有约数中最大的一个。 因为之前做一个小功能,需要先计算一下数组的最大公约数,所以我就想记录一下...

woshixin
今天
3
0
学习Node.js的电子书大全

在这里,与大家分享一批很有用的 Node.js 的电子书资源。Node 是一个服务器端的 JavaScript 解释器,它将改变服务器应该如何工作的概念。它的目标是帮助程序员构建高度可伸缩的应用程序,编写...

jay603
今天
58
0
《伟大的博弈》读后感作文4100字

《伟大的博弈》读后感作文4100字: 五一小长假,作为工厂员工,没能跟上大家放假的步伐,窝家里两天没出门,逼着自己看完《伟大的博弈》,感触颇多。似乎不能消化,先记录第一遍作为幼稚的见...

原创小博客
昨天
5
0
单点登录-基于Redis+MySQL实现单点登录(SSO)

1. 为什么要用单独登录? 主要便于公司内部多系统统一认证授权管理,一次登录可访问多个跨域系统,也同时更加方便统一管理用户登录(员工离职需要拿掉登录权限、统计所有用户对系统的登录请求...

秋日芒草
昨天
2
0
827. Making A Large Island

思想: 将所有连通的 1 分成一个组,分配编号,然后使用BFS统计1的个数,得到这个组的面积。 遍历格子里所有为 0 的元素,检查四个方向的1所在的组并加上这个组面积。于是得到当前元素为 0 ...

reter
昨天
6
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部