程序博客网 > tensorflow 1080

[Python]装饰器

来源：互联网 发布：tensorflow 1080 编辑：程序博客网 时间：2024/06/10 06:16

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

1. 装饰器入门

1.1. 需求是怎么来的？

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

[python] view plaincopyprint?
  1. def foo():  
  2.     print 'in foo()'  
  3.     
  4. foo()  

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

[python] view plaincopyprint?
  1. import time  
  2. def foo():  
  3.     start = time.clock()  
  4.     print 'in foo()'  
  5.     end = time.clock()  
  6.     print 'used:', end - start  
  7.     
  8. foo()  

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

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

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

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

[python] view plaincopyprint?
  1. import time  
  2.     
  3. def foo():  
  4.     print 'in foo()'  
  5.     
  6. def timeit(func):  
  7.     start = time.clock()  
  8.     func()  
  9.     end =time.clock()  
  10.     print 'used:', end - start  
  11.     
  12. timeit(foo)  

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

1.3. 最大限度地少改动！

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

[python] view plaincopyprint?
  1. #-*- coding: UTF-8 -*-   
  2. import time  
  3.     
  4. def foo():  
  5.     print 'in foo()'  
  6.     
  7. # 定义一个计时器，传入一个，并返回另一个附加了计时功能的方法  
  8. def timeit(func):  
  9.         
  10.     # 定义一个内嵌的包装函数，给传入的函数加上计时功能的包装   
  11.     def wrapper():  
  12.         start = time.clock()  
  13.         func()  
  14.         end =time.clock()  
  15.         print 'used:', end - start  
  16.         
  17.     # 将包装后的函数返回   
  18.     return wrapper  
  19.     
  20. foo = timeit(foo)  
  21. foo()  

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

这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了 ：）

2. Python的额外支持

2.1. 语法糖

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

[python] view plaincopyprint?
  1. import time  
  2.     
  3. def timeit(func):  
  4.     def wrapper():  
  5.         start = time.clock()  
  6.         func()  
  7.         end =time.clock()  
  8.         print 'used:', end - start  
  9.     return wrapper 
  10.    
  11. @timeit  
  12. def foo():  
  13.     print 'in foo()'  
  14.     
  15. foo()  

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

2.2. 内置的装饰器

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

[python] view plaincopyprint?
  1. class Rabbit(object):  
  2.         
  3.     def __init__(self, name):  
  4.         self._name = name  
  5.        
  6.     @staticmethod  
  7.     def newRabbit(name):  
  8.         return Rabbit(name)  
  9.        
  10.     @classmethod  
  11.     def newRabbit2(cls):  
  12.         return Rabbit('') 
  13.        
  14.     @property  
  15.     def name(self):  
  16.         return self._name  

这里定义的属性是一个只读属性，如果需要可写，则需要再定义一个setter：

2.3. functools模块

functools模块提供了两个装饰器。这个模块是Python 2.5后新增的，一般来说大家用的应该都高于这个版本。但我平时的工作环境是2.4 T-T

2.3.1. wraps(wrapped[,assigned][, updated]):
这是一个很有用的装饰器。看过前一篇反射的朋友应该知道，函数是有几个特殊属性比如函数名，在被装饰后，上例中的函数名foo会变成包装函数的名字wrapper，如果你希望使用反射，可能会导致意外的结果。这个装饰器可以解决这个问题，它能将装饰过的函数的特殊属性保留。

[python] view plaincopyprint?
  1. import time  
  2. import functools  
  3.     
  4. def timeit(func):  
  5.     @functools.wraps(func)  
  6.     def wrapper():  
  7.         start = time.clock()  
  8.         func()  
  9.         end =time.clock()  
  10.         print 'used:', end - start  
  11.     return wrapper 
  12.    
  13. @timeit  
  14. def foo():  
  15.     print 'in foo()'  
  16.     
  17. foo()  
  18. print foo.__name__  

2.3.2. total_ordering(cls): 首先注意第5行，如果注释这一行，foo.__name__将是'wrapper'。另外相信你也注意到了，这个装饰器竟然带有一个参数。实际上，他还有另外两个可选的参数，assigned中的属性名将使用赋值的方式替换，而updated中的属性名将使用update的方式合并，你可以通过查看functools的源代码获得它们的默认值。对于这个装饰器，相当于wrapper =functools.wraps(func)(wrapper)。

这个装饰器在特定的场合有一定用处，但是它是在Python 2.7后新增的。它的作用是为实现了至少__lt__、__le__、__gt__、__ge__其中一个的类加上其他的比较方法，这是一个类装饰器。如果觉得不好理解，不妨仔细看看这个装饰器的源代码：

[python] view plaincopyprint?
  1. def total_ordering(cls):  
  2.     """Class decorator that fills in missing ordering methods"""  
  3.     convert = {  
  4.         '__lt__': [('__gt__', lambda self, other: other < self),  
  5.                    ('__le__', lambda self, other: not other < self),  
  6.                    ('__ge__', lambda self, other: not self < other)],  
  7.        '__le__': [('__ge__', lambda self, other: other <= self),  
  8.                    ('__lt__', lambda self, other: not other <= self),  
  9.                    ('__gt__', lambda self, other: not self <= other)],  
  10.         '__gt__': [('__lt__', lambda self, other: other > self),  
  11.                    ('__ge__', lambda self, other: not other > self),  
  12.                    ('__le__', lambda self, other: not self > other)],  
  13.         '__ge__': [('__le__', lambda self, other: other >= self),  
  14.                    ('__gt__', lambda self, other: not other >= self),  
  15.                    ('__lt__', lambda self, other: not self >= other)]  
  16.     }  
  17.     roots = set(dir(cls)) & set(convert)  
  18.     if not roots:  
  19.         raise ValueError('must define at least one ordering operation: < > <= >=')  
  20.     root = max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__  
  21.     for opname, opfunc in convert[root]:  
  22.         if opname not in roots:  
  23.             opfunc.__name__ = opname  
  24.             opfunc.__doc__ = getattr(int, opname).__doc__  
  25.             setattr(cls, opname, opfunc)  
  26.     return cls  

 文章转自：http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html

0 0
tensorflow 1080 tensorflow 1080
原创粉丝点击
热门IT博客
安妮宝贝老公 知乎安妮宝贝老公 知乎
linux 防火墙设置linux 防火墙设置
python基础教程 pdf
淘宝上十个最辣的零食
php常用扩展
sql 加列
花与剑js mp3百度云
jsp项目实例源码下载
mac windows 如何切换
知合控股 官网
葫芦侠看电影软件
如何开一个淘宝店铺
lz是什么意思网络用语
linux cp 当前目录
浏览器地址栏执行js
囚徒健身软件
fluent16.0软件下载
python中
知乎诈骗案公益
顶尖电子称软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 洗碗池图片 厨房洗碗池图片 洗碗池怎么安装 洗碗池安装示意图 洗碗池尺寸 碗池 厨房洗碗池 洗碗池什么牌子好 洗碗池哪个牌子好 洗碗池漏水 洗碗池疏通 简易洗碗池 消毒池 洗碗液配方 洗碗液 洗碗机用洗碗液 洗碗精 太平福禄加倍 人寿福禄双喜保险 太平人寿福禄康瑞条款 福禄克万用表型号 符镇穹苍 穹苍 穹苍破斗 破苍斗穹 穹苍是什么意思 如何洗窗帘 新窗帘要洗吗 洗窗帘机器 滚筒洗衣机洗窗帘 窗帘可以用洗衣机洗吗 洗窗帘价格是多少 窗帘脏了不用拆不用洗 窗帘能用洗衣机洗吗 如何清洗窗帘 怎么洗窗帘 窗帘如何清洗 怎样清洗窗帘 洗窗帘 打孔窗帘怎么洗 洗衣服简笔画

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里