函数是个对象，并且可以赋值给一个变量，通过变量也能调用该函数：
>>> def now():
... print('2017-12-28')
...
>>> l = now
>>> l()
2017-12-28
利用函数的_name_属性，可以拿到函数的名字：
>>> now.__name__
'now'
>>> l.__name__
'now'
如果我们在调用函数now()前后自动打印日志，但又不允许修改now()函数的定义——在代码运行期间动态增加功能的方式，称之为‘装饰器’Decorator。
比如，定义一个能打印日志的decorator：
>>> def log(func):
... def wrapper(*args,**kw):
... print('call %s():' % func.__name__)
... return func(*args,**kw)
... return wrapper
...
观察log 函数，发现，本质上这就是一个返回函数的高阶函数！log作为一个decorator，接收一个函数作为参数，冰饭一个函数。借助python的@语法，把decorator置于函数的定义的地方：
>>> @log
... def now():
... print('2017-12-28')
...
>>> now()
call now():
2017-12-28
在调用now()函数时候，不仅运行了now函数，还会在此之前打印一行日志。
其实，把@log放到now()函数的定义前，相当于执行了：
now = log(now)
log是一个decorator，返回一个函数，返回的这个函数名字叫wrapper，原来的now()函数还存在，这个时候now变量指向了这个返回函数wrapper。当调用now()将执行新的函数wrapper函数。wrapper函数的参数是(*args,**kw)，因此wrapper()函数可以接受任意参数！在wrapper函数内部，首先打印日志，再紧接着调用原始函数。
分割线-------------------------------
如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数。比如要自定义log的文本，定义、用法和结果：
>>> def log(text):
... def decorator(func):
... def wrapper(*args,**kw):
... print('%s %s():' %(text,func.__name__))
... return func(*args,**kw)
... return wrapper
... return decorator
...
>>> @log('执行')
... def now():
... print('2017-12-28')
...
>>> now()
执行 now():
2017-12-28
前面的例子中包含了两层def嵌套，后面的例子中包含了三层def嵌套。其实，三层嵌套的效果类似：
now = log('执行')(now)
解析：首先执行log('执行')，返回的是decorator函数，再调用返回函数，参数是now函数，最终的返回值是wrapper函数。
但是，我们执行下面语句来测试：
>>> now.__name__
'wrapper'
我们发现：经过decorator装饰后的函数，他们的__name__属性已经从now变成了wrapper。这是因为返回的那个函数wrapper函数名字就是wrapper，所以，需要把原始函数的__name__属性复制到wrapper函数中，否则，其他一些依赖函数签名的代码执行就会报错。
实际上我们并不需要编写wrapper.__name__ = func.__name__这样的代码，python内置了functools.wraps就是为了这个。最
最后一步，一个完整的decorator的写法如下：
>>> import functools
>>> def log(func):
... @functools.wraps(func)
... def wrapper(*args,**kw):
... print('执行 %s()' %func.__name__)
... return func(*args,**kw)
... return wrapper
...
>>> @log
... def now():
... print('日志')
...
>>> now
<function now at 0x03317198>
>>> now()
执行 now()
日志
针对带有参数的decorator：
>>> import functools
>>> def log(text):
... def decorator(func):
... @functools.wraps(func)
... def wrapper(*args,**kw):
... print('%s %s()' %(text,func.__name__))
... return func(*args,**kw)
... return wrapper
... return decorator
...
>>> @log('ABC')
... def now():
... print('这么复杂干嘛')
...
>>> now()
ABC now()
这么复杂干嘛
例子：设计一个decorator，可作用于任何函数上，并打印该函数的执行时间：
>>> import time,functools
>>> def log(func):
... @functools.wraps(func)
... def wrapper(*args,**kw):
... t1 = time.time()
... r = func(*args,**kw)
... print('%s excute in %s ms'%(func.__name__,1000*(time.time()-t1)))
... return r
... return wrapper
...
>>> @log
... def fast(x,y):
... return x+y
...
>>> @log
... def slow(x,y,z):
... time.sleep(0.1234)
... return x*y*z
...
>>> @log
... def fast(x,y):
... time.sleep(0.0012)
... return x+y
...
>>> fast(3,5)
fast excute in 2.0973682403564453 ms
8
>>> slow(4,5,6)
slow excute in 124.2520809173584 ms
120