#coding:utf8i=10#int对象printid(i),type(i)#,typeints=hello#str对象printid(s),type(s),s.index(o)#,typestr,4d={k:10}#dict对象printid(d),type(d),d.get(k)#,typedict,10defhello():#function对象printHelloWorldprintid(hello),type(hello),hello.func_name,hello()#,typefunction,hello,HelloWorldhello2=hello#传递对象printid(hello2),type(hello2),hello2.func_name,hello2()#,typefunction,hello,HelloWorld#构建一个类classPerson(object):def__init__(self,name):self.name=namedefsay(self):returnIam%s%self.nameprintid(Person),type(Person),Person.say#,typetype,unboundmethodPerson.sayperson=Person(tom)#实例化一个对象printid(person),type(person),#,class__main__.Personprintperson.name,person.say,person.say()#tom,boundmethodPerson.sayof__main__.Personobjectat0xb,Iamtom我们可以看到，常见的这些类型：int、str、dict、function，甚至class、instance都可以调用id和type获得对象的唯一标识和类型。例如方法的类型是function，类的类型是type，并且这些对象都是可传递的。方法对象可传递会带来什么好处呢？这么做的好处就是，我们可以实现一个「闭包」，而「闭包」就是实现一个装饰器的基础。闭包假设我们现在想统计一个方法的执行时间，通常实现的逻辑如下：
#coding:utf8importtimedefhello():start=time.time()#开始时间time.sleep(1)#模拟执行耗时printhelloend=time.time()#结束时间printdurationtime:%ds%int(end-start)#计算耗时hello()#Output:#hello#durationtime:1s统计一个方法执行时间的逻辑很简单，只需要在调用这个方法的前后，增加时间的记录就可以了。但是，统计这一个方法的执行时间这么写一次还好，如果我们想统计任意一个方法的执行时间，每个方法都这么写，就会有大量的重复代码，而且不宜维护。如何解决？这时我们通常会想到，可以把这个逻辑抽离出来：
#coding:utf8importtimedeftimeit(func):#计算方法耗时的通用方法start=time.time()func()#执行方法end=time.time()printdurationtime:%ds%int(end-start)defhello():time.sleep(1)printhellotimeit(hello)#调用执行这里我们定义了一个timeit方法，而参数传入一个方法对象，在执行完真正的方法逻辑后，计算其运行时间。这样，如果我们想计算哪个方法的执行时间，都按照此方式调用即可。
timeit(func1)#计算func1执行时间timeit(func2)#计算func2执行时间虽然此方式可以满足我们的需求，但有没有觉得，本来我们想要执行的是hello方法，现在执行都需要使用timeit然后传入hello才能达到要求，有没有一种方式，既可以给原来的方法加上计算时间的逻辑，还能像调用原方法一样使用呢？答案当然是可以的，我们对timeit进行改造：
#coding:utf8importtimedeftimeit(func):definner():start=time.time()func()end=time.time()printdurationtime:%ds%int(end-start)returninnerdefhello():time.sleep(1)printhellohello=timeit(hello)#重新定义hellohello()#像调用原始方法一样使用注意观察timeit的变动，它在内部定义了一个inner方法，此方法内部的实现与之前类似，但是，timeit最终返回的不是一个值，而是inner对象。所以当我们调用hello=timeit(hello)时，会得到一个方法对象，那么此时变量hello其实是inner，在执行hello()时，真正执行的是inner方法。我们对hello方法进行了重新定义，这么一来，hello不仅保留了其原有的逻辑，而且还增加了计算方法执行耗时的新功能。回过头来，我们分析一下timeit这个方法是如何运行的？在Python中允许在一个方法中嵌套另一个方法，这种特殊的机制就叫做「闭包」，这个内部方法可以保留外部方法的作用域，尽管外部方法不是全局的，内部方法也可以访问到外部方法的参数和变量。装饰器明白了闭包的工作机制后，那么实现一个装饰器就变得非常简单了。Python支持一种装饰器语法糖「
」，使用这个语法糖，我们也可以实现与上面完全相同的功能：#coding:utf8
timeit#相当于hello=timeit(hello)defhello():time.sleep(1)printhellohello()#直接调用原方法即可看到这里，是不是觉得很简单？这里的timeit其实就等价于hello=timeit(hello)。装饰器本质上就是实现一个闭包，把一个方法对象当做参数，传入到另一个方法中，然后这个方法返回了一个增强功能的方法对象。这就是装饰器的核心，平时我们开发中常见的装饰器，无非就是这种形式的变形而已。functools.wraps现在我们已经得知，装饰器其实就是先定义好一个闭包，然后使用语法糖来装饰方法，最后达到重新定义方法的作用。也就是说，最终我们执行的，其实是另外一个被添加新功能的方法。还是拿上面的例子来看，虽然我们调用的方法还是hello，但是最终执行的却是inner，虽然功能和结果没有影响，但是执行的方法却被替换了，这会带来什么影响呢?我们看下面的例子：#coding:utf8
timeitdefhello():time.sleep(1)printhelloprinthello.__name__#输出hello方法的名字#Output:#inner我们看到，虽然我们调用的是hello，但是输出hello方法的名字却是inner。理想情况下，我们希望被装饰的方法，除了增加额外的功能之外，方法的属性信息依旧可以保留原来的，否则在使用中，可能存在一些隐患。如何解决这个问题？在Python内置的functools模块中，提供了一个wraps方法，专门来解决这个问题。#coding:utf8importtimefromfunctoolsimportwrapsdeftimeit(func):
wraps(func)#使用wraps装饰内部方法innerdefinner():start=time.time()func()end=time.time()printdurationtime:%ds%int(end-start)returninnertimeitdefhello():time.sleep(1)printhelloprinthello.__name__#输出hello方法的名字#Output:#hello使用functools模块的wraps方法装饰内部方法inner后，我们再获取hello的属性，都能得到来自原方法的信息了。装饰带参数的方法上面的例子，我们实现了一个最简单的装饰器，装饰的方法hello是没有参数的，如果hello需要参数，此时装饰器如何实现？#coding:utf8importtimefromfunctoolsimportwrapsdeftimeit(func):
wraps(func)definner(name):#inner也需加对应的参数start=time.time()func(name)end=time.time()printdurationtime:%ds%int(end-start)returninnertimeitdefhello(name):#加了一个参数time.sleep(1)printhello%s%namehello(张三)由于最终调用的是inner方法，被装饰的方法hello如果想加参数，那么对应的inner也添加相应的参数就可以了。但是，我们定义的timeit是一个通用的装饰器，现在为了适应hello的参数，而在inner中加了一个参数，那如果要装饰的方法，有2个甚至更多参数，怎么办？难道要在inner中加继续加参数吗？这当然是不行的，我们需要一个一劳永逸的方案来解决。我们改造如下：#coding:utf8importtimefromfunctoolsimportwrapsdeftimeit(func):
wraps(func)definner(*args,**kwargs):#使用*args,**kwargs适应所有参数start=time.time()func(*args,**kwargs)#传递参数给真实调用的方法end=time.time()printdurationtime:%ds%int(end-start)returninnertimeitdefhello(name):time.sleep(1)printhello%s%nametimeitdefsay(name,age):printhello%s%s%(name,age)timeitdefsay2(name,age=20):printhello%s%s%(name,age)hello(张三)say(李四,25)say2(王五)我们把inner方法的参数改为了*args,**kwargs，然后调用真实方法时传入参数func(*args,**kwargs)，这样一来，我们的装饰器就可以装饰有任意参数的方法了，这个装饰器就变得非常通用了。带参数的装饰器被装饰的方法有参数，装饰器内部方法使用*args,**kwargs来适配。但我们平时也经常看到，有些装饰器也是可以传入参数的，这种如何实现呢？#coding:utf8importtimefromfunctoolsimportwrapsdeftimeit(prefix):#装饰器可传入参数defdecorator(func):#多一层方法嵌套
wraps(func)defwrapper(*args,**kwargs):start=time.time()func(*args,**kwargs)end=time.time()print%s:durationtime:%ds%(prefix,int(end-start))returnwrapperreturndecoratortimeit(prefix1)defhello(name):time.sleep(1)printhello%s%name实际上，装饰器方法多加一层内部方法就可以了。我们在timeit中定义了2个内部方法，然后让timeit可以接收参数，返回decorator对象，而在decorator方法中再返回wrapper对象。通过这种方式，由2个内部方法嵌套的方法，就可以实现一个带参数的装饰器。类实现装饰器上面几个例子，都是用方法实现的装饰器，除了用方法实现装饰器，还有没有其他方法实现？答案是肯定的，我们还可以用类来实现一个装饰器，也可以达到相同的效果。#coding:utf8importtimefromfunctoolsimportwrapsclassTimeit(object):"""用类实现装饰器"""def__init__(self,prefix):self.prefix=prefixdef__call__(self,func):
wraps(func)defwrapper(*args,**kwargs):start=time.time()func(*args,**kwargs)end=time.time()print%s:durationtime:%ds%(self.prefix,int(end-start))returnwrapperTimeit(prefix)defhello():time.sleep(1)printhellohello()#调用被装饰的方法用类实现一个装饰器，与方法实现类似，只不过用类利用了__init__和__call__方法，其中__init__定义了装饰器的参数，__call__会在调用Timeit对象的方法时触发。你可以这样理解：t=Timeit(prefix)会调用__init__，而t(hello)会调用__call__(hello)。是不是很巧妙？这些都归功于Python的魔法方法，我会在后面的文章中，单独讲解关于Python魔法方法的实现原理。装饰器使用场景知道了如何实现一个装饰器，那么我们可以在不修改原方法的情况下，给方法增加额外的功能，这就非常适合给方法集成一些通用的逻辑，例如记录日志、记录执行耗时、本地缓存等功能。下面我列举几个用装饰器实现的常用功能，供你参考。记录调用日志importloggingfromfunctoolsimportwrapsdeflogging(func):
wraps(func)defwrapper(*args,**kwargs):#记录调用日志logging.info(callmethod:%s%s%s,func.func_name,args,kwargs)returnfunc(*args,**kwargs)returnwrapper记录方法执行耗时fromfunctoolsimportwrapsdeftimeit(func):
wraps(func)defwrapper(*args,**kwargs):start=time.time()result=func(*args,**kwargs)duration=int(time.time()-start)#统计耗时printmethod:%s,time:%s%(func.func_name,duration)returnresultreturnwrapper记录方法执行次数fromfunctoolsimportwrapsdefcounter(func):
wraps(func)defwrapper(*args,**kwargs):wrapper.count=wrapper.count+1#累计执行次数printmethod:%s,count:%s%(func.func_name,wrapper.count)returnfunc(*args,**kwargs)wrapper.count=0returnwrapper本地缓存fromfunctoolsimportwrapsdeflocalcache(func):cached={}miss=object()
wraps(func)defwrapper(*args):result=cached.get(args,miss)ifresultismiss:result=func(*args)cached[args]=resultreturnresultreturnwrapper路由映射classRouter(object):def__init__(self):self.url_map={}defregister(self,url):defwrapper(func):self.url_map[url]=funcreturnwrapperdefcall(self,url):func=self.url_map.get(url)ifnotfunc:raiseValueError(Nourlfunction:%s,url)returnfunc()router=Router()
router.register(/page1)defpage1():returnthisispage1router.register(/page2)defpage2():returnthisispage2printrouter.call(/page1)printrouter.call(/page2)除此之外，装饰器还能用在权限校验、上下文处理等场景中。你可以根据自己的业务场景，开发对应的装饰器。总结这篇文章，我们主要讲解了Python装饰器是如何实现的。在讲解之前，我们先理解了Python中一切皆对象的概念，基于这个概念，我们理解了实现装饰器的本质：闭包。闭包可以传入一个方法对象，然后返回一个增强功能的方法对象，然后配合Python提供的语法糖，我们就可以实现一个装饰器。实现了简单的装饰器之后，我们还可以继续改进，通过在装饰器中嵌套多个内部方法的方式，让装饰器装饰带有参数的方法，还可以让装饰器也接收参数，非常方便。除了用方法实现一个装饰器之外，我们还可以通过Python的魔法方法，用类来实现一个装饰器。最后，我们分析了使用装饰器的常见场景，主要包括权限校验、日志记录、方法调用耗时、本地缓存、路由映射等功能。使用装饰器的好处是，可以把我们的业务逻辑和控制逻辑分离开，业务开发人员可以更好地