python 进阶：修饰器的介绍

　　参考链接：Python 函数装饰器

　　我认为python中的装饰器是一个很厉害的功能，他能瞬间提升代码的逼格，但对于我这样的小白来说，别说为所欲为的使用了，就连简单的尝试一下，却也是难于登天。经过长达半年的努力，我终于找到了大部分装饰器的介绍信息，鲁迅曾经说过，良好的开始就代表了成功的一半，在我看来，鲁迅分明还是太保守，良好的开端无疑代表你已经成功了。比如接下来我们只需要Ctrl+C+V，就可以完成装饰器的学习了，亲爱的小朋友们，你们学会了吗？

给大人看的分割线

---

装饰器是用来给已经定义好的函数增加功能用的，能在方法运行期间动态增加方法的功能

1）不会改变原来的代码结构。

为什么这么说呢，因为相比于另一种方法：只将函数作为变量传入另一个函数从而来减少重合，使用装饰器并不需要将函数调用改写

#定义这个函数来为类似foo（）的需要去增加loging.warn()的全部函数增添这个loging.warn()的功能
#假如有许多函数和foo()一样，都需要增加loging.warn()这行代码，我们就可以定义一个函数，然后将每个需要增加功能的函数作为参数传入
#但是这样必须在用use_logging(foo)去替换原有的foo()这就改变了函数的调用，破坏了原有的代码结构
def use_logging(func):
    logging.warn("%s is running" % func.__name__)
    func()

def foo():
    print('i am foo')

use_logging(foo)

2）装饰器在不修改函数代码的前提下影响代码的功能；调用python中的函数可以作为变量去传递，基于这一特性，我们可以构建出自己的装饰器；

先来了解一些基础知识：

　　1）我们可以将函数作为变量传递。要注意括号，加了括号就会运行函数。

　　2）在函数的内部还可以嵌套函数

def hi(name="yasoob"):
    print("现在在hi（）里面运行")
 
    def greet():
        return "现在在greet()里面运行"
 
    def welcome():
        return "现在在welcom()里面运行"
    print(greet())
    print(welcome())
    print("现在你返回到了hi()里面")
 
hi()

# 上面展示了无论何时你调用hi(), greet()和welcome()将会同时被调用。
# 然后greet()和welcome()函数在hi()函数之外是不能访问的，比如

　　结果：

现在在hi（）里面运行
现在在greet()里面运行
现在在welcom()里面运行
现在你返回到了hi()里面

　　

　3）从函数中返回函数

def hi(name="yasoob"):
    def greet():
        return "now you are in the greet() function"
 
    def welcome():
        return "now you are in the welcome() function"
 
    if name == "yasoob":
        return greet
    else:
        return welcome
 
a = hi()
print(a)
#outputs: <function greet at 0x7f2143c01500>
 
#上面清晰地展示了`a`现在指向到hi()函数中的greet()函数
#现在试试这个
 
print(a())
#outputs: now you are in the greet() function

　　注意下面的 hi()返回的值是greet，加上后面的括号时，就成为了greet（）随即开始运行

 hi()() #这会输出 now you are in the greet() function。

　　

　4）将函数作为参数传递给另外一个函数

def hi():
    return "hi yasoob!"
 
def doSomethingBeforeHi(func):
    print("I am doing some boring work before executing hi()")
    print(func())
 
doSomethingBeforeHi(hi)    #注意不要加括号
#outputs:I am doing some boring work before executing hi()
#        hi yasoob!

　　

第一个修饰器

def a_new_decorator(a_func):
    def wrapTheFunction():
        print('我在a_func执行前做一些事情')
        a_func()
        print('我在a_func执行后做一些事情')
    return wrapTheFunction  #记得把这个内定义的函数返回

def a_function_requiring_decoration():  #定义一个函数，等会用修饰器来修饰
    print('我是需要用修饰器修饰的函数')

#使用修饰器
a_function_requiring_decoration=a_new_decorator(a_function_requiring_decoration)
a_function_requiring_decoration()

　　结果：

我在a_func执行前做一些事情
我是需要用修饰器修饰的函数
我在a_func执行后做一些事情

　

真正的装饰器：decorator

 　　另一种生成被装饰函数的方法：用@

补充----------------

　　装饰器，只能在函数运行前做一些事情，也能在函数运行后执行，不过要是有返回结果的就不能在其后执行了，因为有return语句但是可以将装饰器写成这样

def log(parameter1):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args,**kw):
                s=func(*args,**kw)
                print('函数%s()运行消耗时间%.11f'%(func.__name__,parameter1))
                return s#前面执行，这里返回
            return wrapper
        return decorator

　　

补充结束------------------

先了解一下@语句

最简单的装饰器

　　如果被装饰的函数运行时不需要参数，我们可以这样定义装饰器

def metric(fn):
    print('%s executed in %s ms' % (fn.__name__, 10.24))
    return fn
@metric
def customize(a,b):
　　print("我是被装饰的函数,运行结果%d"%a+b)
customize(1,3)

#输出
customize executed in 10.24 ms
我是被装饰的函数,运行结果4

　　把@metric放到customize()函数的定义处，相当于执行了语句：

customize=metric(customize)

　　由于metric()是一个decorator，返回一个函数，所以，原来的customize()函数仍然存在，只是现在同名的customize变量指向了新的函数，于是调用customize()将执行新函数，即在metric()函数中返回的wrapper中返回的customize函数。

普遍使用的装饰器的格式

　　上面的只是最简单的，我们通常使用装饰器的时候都需要被装饰的函数的运行结果，当被装饰的函数需要参数时，使用上面的定义就不行了：

　　

decorator实际上也是一个返回函数的函数，不过他返回的函数并不是我们要装饰的函数。

装饰器是在方法执行的过程中动态的为方法增加功能的一种方式，不知道我们能不能想到，这种方式可以通过先运行要增加的功能，然后再运行要修饰的对象函数

而两部过程应该放到一个方法体中，而装饰器返回的就是包含这两步过程的一个函数。

另外需要注意的是参数，装饰器接受的参数是要修饰的方法名，其内部的函数接受的是要修饰的方法需要的参数(用*args,**kw)来表示就好

在这个函数中，先运行计划为函数增加功能的代码，然后运行函数

最后，通过python的@语法将这个装饰器“绑定”到要修饰的方法上

def a_new_decorator(a_func):
    def wrapTheFunction():
        print('我在a_func执行前做一些事情')
        a_func()
        print('我在a_func执行后做一些事情')
    return wrapTheFunction  #记得把这个内定义的函数返回

#不同之处在这里
@a_new_decorator
def a_function_requiring_decoration():  #定义一个函数，等会用修饰器来修饰
    print('我是需要用修饰器修饰的函数')


a_function_requiring_decoration()

　　把@log放到now()函数的定义处，相当于执行了语句：

now = log(now)

　　

由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

解决被修饰的函数会被重命名问题的wraps函数

　　使用上面会出现一个问题，获取_name_时会返回被修饰器内置函数的名字

print(a_function_requiring_decoration.__name__)
# Output: wrapTheFunction　　应该返回a_function_requiring_decoration

之所以返回的是修饰器里内置的名字，是因为它会重写函数的名字和注释文档

而python提供了 functools.wraps() 来解决这个办法，以如下代码为例说明 functolls.wraps 使用方法

from functools import wraps
 
def a_new_decorator(a_func):
    @wraps(a_func)
    def wrapTheFunction():
        ---snip---
　　　　return a_func
    return wrapTheFunction
 
@a_new_decorator
def a_function_requiring_decoration():
    ---snip--
 
print(a_function_requiring_decoration.__name__)
# Output: a_function_requiring_decoration

@wraps 接受一个被修饰函数的名字，并加入了复制函数名称、注释文档、参数列表等功能，这让我们能在修饰器里访问函数被修饰之前的属性

怎样为修饰器传入参数：

　　

假如装饰器也需要一些参数怎么办呢，比如我们想要输出日志的同时还要输出程序的运行时间.这需要三个函数来完成，绑定最外面的函数，其他的可以看作不变

　　假如 a_function_requiring_decoration（） 需要参数

def a_function_requiring_decoration(name):
    --snip--

　　我们需要在定义 wrapTheFunction() 时指定参数即：

def wrapTheFunction(name):
        ---snip---
　　　　return a_func(name)

　　当装饰器不知道要装饰的函数有多少个参数时，可以用 *args 来代替

def wrapTheFunction(*args):
        ---snip---
　　　　return a_func(*args)

　　当需要关键字参数时

def a_function_requiring_decoration(name, age=None, height=None): 
　　print("I am %s, age %s, height %s" % (name, age, height))

　　可以这样

def wrapTheFunction(*args, **kwargs): 
　　# args是一个数组，kwargs一个字典 
　　logging.warn("%s is running" % func.__name__) 
　　return func(*args, **kwargs) 

　　和两层嵌套的decorator相比，3层嵌套的效果是这样的：

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('execute')
def now():
    print('2015-3-25')

　　和两层嵌套的decorator相比，3层嵌套的效果是这样的：

>>> now = log('execute')(now)

　　我们来剖析上面的语句，首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。

原文链接 >>>点击<<<