想请教一下 python 装饰器的作用
19:07:51 +08:00 · 2224 次点击
之前理解 python 装饰器等于是在函数执行前先执行装饰器函数，但是直接写一个函数调用或者写回调函数比有什么区别呢？
第 1 条附言 &·&
12:08:29 +08:00
感谢各位回答，我总结了一下大家的意见
1.减少函数嵌入
2.函数前置拦截
3.提高代码可读性
22 回复 &| &直到
14:07:52 +08:00
& & 19:13:04 +08:00 via Android
能写在一行里(逃…
& & 19:22:49 +08:00
功能上没区别，看上去更自然。
& & 19:27:01 +08:00
& & 19:30:00 +08:00
装饰器模式的好处
& & 19:30:34 +08:00 via Android
先后顺序的差别吧，装饰器总是比被装饰函数先执行，它可以决定如何使用被装饰函数。
& & 19:38:28 +08:00
是在函数定义后以函数作为参数执行装饰器函数，返回值还绑定到原来的名字上。
& & 19:41:10 +08:00
我在实际当中使用过的一个情形:
有一大批函数都需要做相同或相似的参数检查, 每个函数里面都检查会造成大量重复代码, 那么就把检查部分提出来放到一个检查函数, 而这个检查函数返回的是经过参数检查的一系列函数, 也就是函数返回函数, python 里自然就是装饰器了, 只需要在那一系列函数上方套一个 @, 调用这一系列函数就自动完成参数检查了: 避免了重复代码, 避免了到处都要手动调用一个检查函数
& & 20:01:22 +08:00 via Android
为了思路清晰
& & 21:57:47 +08:00
完全可以把 &@& 当做语法糖，也可以直接使?用函数式写法。只不过那样不便于代码维护
& & 22:01:33 +08:00
方便进行维护，而且程序更清晰，很方便给其他函数添加额外的功能。
& & 22:05:55 +08:00
如果能用装饰器上的功能 需要的时候 去掉装饰器一样很容易
& & 22:06:22 +08:00
『装饰器等于是在函数执行前先执行装饰器函数』这句话其实有点问题。
想象这样一个情形，一个外部 python 文件(a.py)中，包含了一个被装饰器(dec)修饰的函数(some_func)。当你在其他文件(b.py)中 import a ，装饰器函数(dec)就被执行了。而不是你调用 some_func 时才执行 dec 。你可以试一下在 dec 中写一句 print ，然后就可以看到 import a 的时候就被 print 出来了。
& & 22:25:53 +08:00
不是执行函数前先执行装饰器
而是在声明函数时先执行装饰器，然后用装饰器输出的那个函数体代替原来准备声明的那个函数体
& & 22:30:47 +08:00 via Android
关键词： AOP
通常用来实现：记录业务日志、做参数统一检验、做事务管理
& & 22:49:09 +08:00
def safe_run(_logger):
def _run_once(func):
def f(*args,**kwargs):
return func(*args,**kwargs)
_logger.error(traceback.format_exc())
return _run_once
在要执行的方法前面加上这个装饰器，放心多了；
& & 23:18:23 +08:00
你们说那么多，还不如看看 flask 或者 bottle 框架是怎么用的，瞬间明白装饰器的好处了。
& & 23:30:29 +08:00 via iPhone
只是好看一点罢了
和写在函数里调用返回个函数没什么区别
类似蛋疼的 feature 还有 js 里的 promise
大张旗鼓的被实现出来实际呢只是让嵌套回调好看一点
& & 00:57:46 +08:00
语法糖，复用方便
& & 08:59:18 +08:00 via Android
14 楼的用法基本就是九成的使用场景，只要写一次装饰器就可以到处使用，概念清晰易理解，何乐而不为呢
& & 09:15:08 +08:00
readability counts.
& & 13:09:23 +08:00
代码重用，也可以完全改变被装饰函数的行为。很灵活的。
& & 14:07:52 +08:00
用上比不用上更能装逼
& · & 1968 人在线 & 最高记录 3541 & · &
创意工作者们的社区
World is powered by solitude
VERSION: 3.9.8.0 · 89ms · UTC 09:20 · PVG 17:20 · LAX 01:20 · JFK 04:20? Do have faith in what you're doing.python装饰器是什么意思_百度知道
python装饰器是什么意思
我有更好的答案
def&f4();f2'def&f3():#&验证1#&nbsp，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题：数据库操作：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构;=&lambda&x:&x&验证1#&验证2#&f1()f2()f3()f4()###&f2'def&nbsp装饰器是程序开发中经常会用到的一个功能;'f3&#39、redis调用，这个功能 有点绕，自学时直接绕过去了，然后面试问到了就挂了、先明白这段代码####&###&f1()f2()f3()f4()过了一周 Low BB 被开除了…老大把工作交给 Low BBB，他是这么做的;验证3print&'###############f1()f2()f3()f4()目前公司有条不紊的进行着;f3'def&'f1&#39，基础平台负责提供底层的功能:#&nbsp，用好了装饰器，开发效率如虎添翼;f2():check_login()print&'f3():check_login()print&'第一波&####def&foo():print&'验证3print&&#39，因为函数&nbsp，因为装饰器是程序开发的基础知识;###############&def&验证3passdef&nbsp，这个都 不会，别跟人家说你会Python, 看了下面的文章;f1'def&验证2#&验证3print&nbsp。诶;f1():check_login()print&'执行下面的lambda表达式，而不再是原来的foo函数：###############&nbsp，如;'f1&#39:print&nbsp，这样一来基础平台就不需要做任何修改了。当天Low B 被开除了…老大把工作交给 Low BB，他是这么做的：###############&基础平台提供的功能如下&验证2#&验证3print&nbsp，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。老大把工作交给 Low B;def&f2();###############&def&+&1foo()&&&#&业务部门B&调用基础平台提供的功能&nbsp，他是这么做的：跟每个业务部门交涉，每个业务部门自己写代码，调用基础平台的功能之前先验证，保证你学会装饰器。1;check_login();def&f3():print&def&f4();业务部门不变&验证1#&验证2#&nbsp:print&foo'调用基础平台提供的功能###&nbsp：只对基础平台的代码进行重构，其他业务部门无需做任何修改###############&基础平台提供的功能如下&nbsp:print&'f2'###############&业务部门A&f1():#&验证1#&'foo'foo&foo()、需求来了初创公司有N个业务部门，1个基础平台部门;foo&&&&&#表示是函数foo()&&&#表示执行foo函数####&第二波&####def&f4'###############&###############&###&业务部门A&业务部门B&调用基础平台提供的功能&foo&被重新定义了2;验证1#&验证2#&'f3&#39、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下;'f4'基础平台提供的功能如下&###############def&f1();def&f2():#&nbsp:#&nbsp:print&调用基础平台提供的功能&###############f1()f2()f3()f4()###############&nbsp，即;f4():check_login()print&'f4'老大看了下Low BBB 的实现，嘴角漏出了一丝的欣慰的笑，语重心长的跟Low BBB聊了个天：老大说：写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：封闭：已实现的功能代码块开放：对扩展开发如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码，老板就给了Low BBB一个实现方案：def&w1(func):def&inner():#&验证1#&验证2#&验证3return&func()return&inner@w1def&f1():print&'f1'@w1def&f2():print&'f2'@w1def&f3():print&'f3'@w1def&f4():print&'f4'& &对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。Low BBB心惊胆战的问了下，这段代码的内部执行原理是什么呢？老大正要生气，突然Low BBB的手机掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一紧一抖，喜笑颜开，交定了Low BBB这个朋友。详细的开始讲解了：单独以f1为例：def&w1(func):def&inner():#&验证1#&验证2#&验证3return&func()return&inner@w1def&f1():print&'f1'& &当写完这段代码后（函数未被执行、未被执行、未被执行），python解释器就会从上到下解释代码，步骤如下：def w1(func): &==&将w1函数加载到内存@w1没错，从表面上看解释器仅仅会解释这两句代码，因为函数在没有被调用之前其内部代码不会被执行。从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章，@函数名&是python的一种语法糖。如上例@w1内部会执行一下操作：执行w1函数，并将 @w1 下面的&函数&作为w1函数的参数，即：@w1 等价于 w1(f1)所以，内部就会去执行：def inner:#验证return f1() & # func是参数，此时 func 等于 f1return inner & & # 返回的 inner，inner代表的是函数，非执行函数其实就是将原来的 f1 函数塞进另外一个函数中将执行完的 w1 函数返回值赋值给@w1下面的函数的函数名w1函数的返回值是：def inner:#验证return 原来f1() &# 此处的 f1 表示原来的f1函数然后，将此返回值再重新赋值给 f1，即：新f1 =&def inner:#验证return 原来f1()所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在 新f1 函数内部先执行验证，再执行原来的f1函数，然后将 原来f1 函数的返回值 返回给了业务调用者。如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着Low BBB 你明白了吗？要是没明白的话，我晚上去你家帮你解决吧！！！先把上述流程看懂，之后还会继续更新…3、问答时间问题：被装饰的函数如果有参数呢？& &#一个参数def&w1(func):def&inner(arg):#&验证1#&验证2#&验证3return&func(arg)return&inner@w1def&f1(arg):print&'f1'& && &#两个参数def&w1(func):def&inner(arg1,arg2):#&验证1#&验证2#&验证3return&func(arg1,arg2)return&inner@w1def&f1(arg1,arg2):print&'f1'& && &#三个参数def&w1(func):def&inner(arg1,arg2,arg3):#&验证1#&验证2#&验证3return&func(arg1,arg2,arg3)return&inner@w1def&f1(arg1,arg2,arg3):print&'f1'& &问题：可以装饰具有处理n个参数的函数的装饰器？& &def&w1(func):def&inner(*args,**kwargs):#&验证1#&验证2#&验证3return&func(*args,**kwargs)return&inner@w1def&f1(arg1,arg2,arg3):print&'f1'& &问题：一个函数可以被多个装饰器装饰吗？def&w1(func):def&inner(*args,**kwargs):#&验证1#&验证2#&验证3return&func(*args,**kwargs)return&innerdef&w2(func):def&inner(*args,**kwargs):#&验证1#&验证2#&验证3return&func(*args,**kwargs)return&inner@w1@w2def&f1(arg1,arg2,arg3):print&'f1'& &问题：还有什么更吊的装饰器吗？#!/usr/bin/env&python#coding:utf-8def&Before(request,kargs):print&'before'def&After(request,kargs):print&'after'def&Filter(before_func,after_func):def&outer(main_func):def&wrapper(request,kargs):before_result&=&before_func(request,kargs)if(before_result&!=&None):return&before_main_result&=&main_func(request,kargs)if(main_result&!=&None):return&main_after_result&=&after_func(request,kargs)if(after_result&!=&None):return&after_return&wrapperreturn&outer@Filter(Before,&After)def&Index(request,kargs):print&'index'& &，所以这也是Python面试中必问的问题，但对于好多小白来讲
【0元入学，两周免费试听】
主营：培训【Python+人工智能，Java大数据，HTML5】
为您推荐：
其他类似问题
您可能关注的内容
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。Python中的装饰器用法详解_python
作者：用户
本文讲的是Python中的装饰器用法详解_python，
本文实例讲述了Python中的装饰器用法。分享给大家供大家参考。具体分析如下：
这里还是先由stackoverflow上面的一个问题引起吧，如果使用如下的代码：
复制代码 代码如下:
@makeitalic
本文实例讲述了Python中的装饰器用法。分享给大家供大家参考。具体分析如下：
这里还是先由stackoverflow上面的一个问题引起吧，如果使用如下的代码：
复制代码 代码如下:
@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
@makeitalic
def hello():
return "hello world"
print hello() ## 返回 &b&&i&hello world&/i&&/b&
现在我们来看看如何从一些最基础的方式来理解Python的装饰器。
装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
1.1. 需求是怎么来的？
装饰器的定义很是抽象，我们来看一个小例子。
复制代码 代码如下:
def foo():
print 'in foo()'
这是一个很无聊的函数没错。但是突然有一个更无聊的人，我们称呼他为B君，说我想看看执行这个函数用了多长时间，好吧，那么我们可以这样做：
复制代码 代码如下:
import time
def foo():
start = time.clock()
print 'in foo()'
end = time.clock()
print 'used:', end - start
很好，功能看起来无懈可击。可是蛋疼的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()
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()
end =time.clock()
print 'used:', end - start
# 将包装后的函数返回
return wrapper
foo = timeit(foo)
这样，一个简易的计时器就做好了！我们只需要在定义foo以后调用foo之前，加上foo = timeit(foo)，就可以达到计时的目的，这也就是装饰器的概念，看起来像是foo被timeit装饰了。在在这个例子中，函数进入和退出时需要计时，这被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言，像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里，能减少大量重复代码。面向切面编程还有相当多的术语，这里就不多做介绍，感兴趣的话可以去找找相关的资料。
这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了 ：）
上面这段代码看起来似乎已经不能再精简了，Python于是提供了一个语法糖来降低字符输入量。
复制代码 代码如下:
import time
def timeit(func):
def wrapper():
start = time.clock()
end =time.clock()
print 'used:', end - start
return wrapper
def foo():
print 'in foo()'
重点关注第11行的@timeit，在定义上加上这一行与另外写foo = timeit(foo)完全等价，千万不要以为@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感觉。
要理解的装饰器，我们首先必须明白在Python中函数也是被视为对象。这一点很重要。先看一个例子：
复制代码 代码如下:
def shout(word="yes") :
return word.capitalize()+" !"
print shout()
# 输出 : 'Yes !'
# 作为一个对象，你可以把函数赋给任何其他对象变量
scream = shout
# 注意我们没有使用圆括号，因为我们不是在调用函数
# 我们把函数shout赋给scream，也就是说你可以通过scream调用shout
print scream()
# 输出 : 'Yes !'
# 还有，你可以删除旧的名字shout，但是你仍然可以通过scream来访问该函数
print shout()
except NameError, e :
#输出 : "name 'shout' is not defined"
print scream()
# 输出 : 'Yes !'
我们暂且把这个话题放旁边，我们先看看python另外一个很有意思的属性：可以在函数中定义函数：
复制代码 代码如下:
def talk() :
# 你可以在talk中定义另外一个函数
def whisper(word="yes") :
return word.lower()+"...";
# ... 并且立马使用它
print whisper()
# 你每次调用'talk'，定义在talk里面的whisper同样也会被调用
# 但是"whisper" 不会单独存在:
print whisper()
except NameError, e :
#输出 : "name 'whisper' is not defined"*
从以上两个例子我们可以得出，函数既然作为一个对象，因此：
1. 其可以被赋给其他变量
2. 其可以被定义在另外一个函数内
这也就是说，函数可以返回一个函数，看下面的例子：
复制代码 代码如下:
def getTalk(type="shout") :
# 我们定义另外一个函数
def shout(word="yes") :
return word.capitalize()+" !"
def whisper(word="yes") :
return word.lower()+"...";
# 然后我们返回其中一个
if type == "shout" :
# 我们没有使用(),因为我们不是在调用该函数
# 我们是在返回该函数
return shout
return whisper
# 然后怎么使用呢 ?
# 把该函数赋予某个变量
talk = getTalk()
# 这里你可以看到talk其实是一个函数对象:
print talk
#输出 : &function shout at 0xb7ea817c&
# 该对象由函数返回的其中一个对象:
print talk()
# 或者你可以直接如下调用 :
print getTalk("whisper")()
#输出 : yes...
还有，既然可以返回一个函数，我们可以把它作为参数传递给函数：
复制代码 代码如下:
def doSomethingBefore(func) :
print "I do something before then I call the function you gave me"
print func()
doSomethingBefore(scream)
#I do something before then I call the function you gave me
这里你已经足够能理解装饰器了，其他它可被视为封装器。也就是说，它能够让你在装饰前后执行代码而无须改变函数本身内容。
那么如何进行手动装饰呢？
复制代码 代码如下:
# 装饰器是一个函数，而其参数为另外一个函数
def my_shiny_new_decorator(a_function_to_decorate) :
# 在内部定义了另外一个函数：一个封装器。
# 这个函数将原始函数进行封装，所以你可以在它之前或者之后执行一些代码
def the_wrapper_around_the_original_function() :
# 放一些你希望在真正函数执行前的一些代码
print "Before the function runs"
# 执行原始函数
a_function_to_decorate()
# 放一些你希望在原始函数执行后的一些代码
print "After the function runs"
#在此刻，"a_function_to_decrorate"还没有被执行，我们返回了创建的封装函数
#封装器包含了函数以及其前后执行的代码，其已经准备完毕
return the_wrapper_around_the_original_function
# 现在想象下，你创建了一个你永远也不远再次接触的函数
def a_stand_alone_function() :
print "I am a stand alone function, don't you dare modify me"
a_stand_alone_function()
#输出: I am a stand alone function, don't you dare modify me
# 好了，你可以封装它实现行为的扩展。可以简单的把它丢给装饰器
# 装饰器将动态地把它和你要的代码封装起来，并且返回一个新的可用的函数。
a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs
现在你也许要求当每次调用a_stand_alone_function时，实际调用却是a_stand_alone_function_decorated。实现也很简单，可以用my_shiny_new_decorator来给a_stand_alone_function重新赋值。
复制代码 代码如下:
a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs
# And guess what, that's EXACTLY what decorators do !
装饰器揭秘
前面的例子，我们可以使用装饰器的语法：
复制代码 代码如下:
@my_shiny_new_decorator
def another_stand_alone_function() :
print "Leave me alone"
another_stand_alone_function()
#Before the function runs
#Leave me alone
#After the function runs
当然你也可以累积装饰：
复制代码 代码如下:
def bread(func) :
def wrapper() :
print "&/''''''\&"
print "&\______/&"
return wrapper
def ingredients(func) :
def wrapper() :
print "#tomatoes#"
print "~salad~"
return wrapper
def sandwich(food="--ham--") :
print food
sandwich()
#输出 : --ham--
sandwich = bread(ingredients(sandwich))
sandwich()
#outputs :
#&/''''''\&
# #tomatoes#
#&\______/&
使用python装饰器语法：
复制代码 代码如下:
@ingredients
def sandwich(food="--ham--") :
print food
sandwich()
#&/''''''\&
# #tomatoes#
#&\______/&
装饰器的顺序很重要，需要注意：
复制代码 代码如下:
@ingredients
def strange_sandwich(food="--ham--") :
print food
strange_sandwich()
##tomatoes#
#&/''''''\&
#&\______/&
最后回答前面提到的问题：
复制代码 代码如下:
# 装饰器makebold用于转换为粗体
def makebold(fn):
# 结果返回该函数
def wrapper():
# 插入一些执行前后的代码
return "&b&" + fn() + "&/b&"
return wrapper
# 装饰器makeitalic用于转换为斜体
def makeitalic(fn):
# 结果返回该函数
def wrapper():
# 插入一些执行前后的代码
return "&i&" + fn() + "&/i&"
return wrapper
@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&
内置的装饰器
内置的装饰器有三个，分别是staticmethod、classmethod和property，作用分别是把类中定义的实例方法变成静态方法、类方法和类属性。由于模块里可以定义函数，所以静态方法和类方法的用处并不是太多，除非你想要完全的面向对象编程。而属性也不是不可或缺的，Java没有属性也一样活得很滋润。从我个人的Python经验来看，我没有使用过property，使用staticmethod和classmethod的频率也非常低。
复制代码 代码如下:
class Rabbit(object):
def __init__(self, name):
self._name = name
@staticmethod
def newRabbit(name):
return Rabbit(name)
@classmethod
def newRabbit2(cls):
return Rabbit('')
def name(self):
return self._name
这里定义的属性是一个只读属性，如果需要可写，则需要再定义一个setter：
复制代码 代码如下:
@name.setter
def name(self, name):
self._name = name
functools模块
functools模块提供了两个装饰器。这个模块是Python 2.5后新增的，一般来说大家用的应该都高于这个版本。但我平时的工作环境是2.4 T-T
2.3.1. wraps(wrapped[, assigned][, updated]): 这是一个很有用的装饰器。看过前一篇反射的朋友应该知道，函数是有几个特殊属性比如函数名，在被装饰后，上例中的函数名foo会变成包装函数的名字wrapper，如果你希望使用反射，可能会导致意外的结果。这个装饰器可以解决这个问题，它能将装饰过的函数的特殊属性保留。
复制代码 代码如下:
import time
import functools
def timeit(func):
@functools.wraps(func)
def wrapper():
start = time.clock()
end =time.clock()
print 'used:', end - start
return wrapper
def foo():
print 'in foo()'
print foo.__name__
首先注意第5行，如果注释这一行，foo.__name__将是'wrapper'。另外相信你也注意到了，这个装饰器竟然带有一个参数。实际上，他还有另外两个可选的参数，assigned中的属性名将使用赋值的方式替换，而updated中的属性名将使用update的方式合并，你可以通过查看functools的源代码获得它们的默认值。对于这个装饰器，相当于wrapper = functools.wraps(func)(wrapper)。
2.3.2. total_ordering(cls): 这个装饰器在特定的场合有一定用处，但是它是在Python 2.7后新增的。它的作用是为实现了至少__lt__、__le__、__gt__、__ge__其中一个的类加上其他的比较方法，这是一个类装饰器。如果觉得不好理解，不妨仔细看看这个装饰器的源代码：
复制代码 代码如下:
def total_ordering(cls):
"""Class decorator that fills in missing ordering methods"""
convert = {
'__lt__': [('__gt__', lambda self, other: other & self),
('__le__', lambda self, other: not other & self),
('__ge__', lambda self, other: not self & other)],
'__le__': [('__ge__', lambda self, other: other &= self),
('__lt__', lambda self, other: not other &= self),
('__gt__', lambda self, other: not self &= other)],
'__gt__': [('__lt__', lambda self, other: other & self),
('__ge__', lambda self, other: not other & self),
('__le__', lambda self, other: not self & other)],
'__ge__': [('__le__', lambda self, other: other &= self),
('__gt__', lambda self, other: not other &= self),
('__lt__', lambda self, other: not self &= other)]
roots = set(dir(cls)) & set(convert)
if not roots:
raise ValueError('must define at least one ordering operation: & & &= &=')
root = max(roots)
# prefer __lt__ to __le__ to __gt__ to __ge__
for opname, opfunc in convert[root]:
if opname not in roots:
opfunc.__name__ = opname
opfunc.__doc__ = getattr(int, opname).__doc__
setattr(cls, opname, opfunc)
return cls
希望本文所述对大家的Python程序设计有所帮助。
以上是云栖社区小编为您精心准备的的内容，在云栖社区的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索python
python装饰器详解、python 装饰器用法、条件函数if的用法详解、英语宾语从句用法详解、英语动词时态用法详解，以便于您获取更多的相关知识。
稳定可靠、可弹性伸缩的在线数据库服务，全球最受欢迎的开源数据库之一
6款热门基础云产品6个月免费体验；2款产品1年体验;1款产品2年体验
弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率
开发者常用软件，超百款实用软件一站式提供
云栖社区(yq.aliyun.com)为您免费提供相关信息，包括
，所有相关内容均不代表云栖社区的意见！