图三

接着我们这想这样的一个问题，在我们最开始学习编程的时候，如果有个题目要求我们输出100个'hello world!',我们自然的想到了，直接print('hello world!')然后写100行,自然也就打印出了100个hello world!，在我们学习了循环之后就知道了直接用一个for循环100次就行了。
同样的在我们学习函数之前，如果你写的程序中会多次引用一段相同的代码，或者是要多次执行相同的功能，然后我们就用函数把这些需要多次调用的功能封装起来，就变成了函数，在面对对象编程中也叫方法。
如果现在有这么一个需求就是在现有的100个函数执行前加上print('hello world!')，那么我们就在学习python的装饰器后就不用批量的在每个函数前面添加代码了，而是使用python的装饰器。

例子
把s.py文件修改问如下所示：

def outer(func):
    def inner():
        print('hello world!')
        return func()
    return inner

@outer
def f1():
    print('装饰器')
    print('f1')

@outer
def f2():
    print('装饰器')
    print('f2')

@outer
def f100():
    print('装饰器')
    print('f3')

然后执行test.py文件，输出结果如下：

hello world!
装饰器
f1
hello world!
装饰器
f2
hello world!
装饰器
f3

分析：相比之前的代码，在test.py文件中调用f1，f2f，f3函数的时除了打印原本的两条语句之前还另外在执行两条语句之前还执行了，print('hello world!')语句。这是为什么呢？这是什么原理呢？

首先我们要清楚，在python中函数是可以赋值给其他变量的，也就是和c语言中的函数指针差不多，一个函数名本身就是值的这个函数的地址，既然是地址那么就是可以传递的。如果我们有了函数的地址，那么也就调用这个函数了。

看下面的例子：

>>> def fun1():          # 定义函数fun1
...     print('fun1')
...
>>> fun1()                 # 调用函数fun1
fun1                            # 调用函数fun1 输出 ‘fun1’
>>> fun2                     # 然后输出看一下  fun2 变量
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'fun2' is not defined #  输出fun2时候 报错  没有定义
>>> fun1                                       #  输出查看fun1 变量为：0x10a7fee18
<function fun1 at 0x10a7fee18>
>>> fun2 = fun1                            #  把fun1 变量的值赋值给 fun2
>>> fun2                                       # 输出fun2 发现和fun1的值一模一样
<function fun1 at 0x10a7fee18>
>>> fun2()                          # 把fun2当作函数调用尽然功能和fun1一模一样
fun1

从以上的例子可以看出来函数名可以通过赋值操作把地址赋值给其他变量并用通过其他变量也可以调用。把这个例子再升级一下：

>>> def fun3(f):   # 定义一个函数，fun3
...     print(f)         #  输出参数f
...     f()                # 特别注意这里，在前面说到了一个变量是可以被赋值成一个函数
... #的地址的，这里的f就是被看成了被赋值成函数地址了，然后通过f被赋值的地址调用那个函数
>>> fun3(fun1)   #  这里在调用fun3的时候把fun1函数的地址传递给fun3的参数
<function fun1 at 0x10a7fee18>   # 可知输出f变量的内容正式上个例子中fun1函数的地址值
fun1

注意这个代码是接这上面一个例子的

然后我们再升级：

>>> def fun4(f):    #照常我们定义一个普通的函数，参数是f
...     def fun5_in_fun4(): #在函数fun4内又定义一个函数fun5_in_fun4
...             print('fun5_in_fun4') # 函数fun5_in_fun4体内的语句输出'fun5_in_fun4'字符串
...     f()            # 调用传入的函数f  其实在下面传入的还是fun1
...     return fun5_in_fun4  #特别注意这里，这里我们把在fun4内定义的函数通过返回值返回
... 
>>> fun = fun4(fun1) # 调用fun4传入fun1，这里用fun来接受fun4的返回值是'fun5_in_fun4'函数地址
fun1    # 在fun4还输内调用了传入的函数fun1 输出 'fun1'字符串
>>> fun()       #  在上一句代码中fun接收了fun4的返回值是一个函数的地址，那么就可以调用fun4内部定义的函数了
fun5_in_fun4    # 调用fun4内部的函数输出'fun5_in_fun4'字符串。

接着我们再改造一下函数fun4

>>> def outer(f):
...     def inner():
...             f()
...             print("fun5_in_fun4")
...             return 'function in fun4'
...     return inner
... 
>>> s = outer(fun1)
>>> string = s()
fun1
fun5_in_fun4
>>> string   # string 得到的返回值便是执行函数 inner 后返回的字符串
'function in fun4'

通过这样一改造是不是就是我们最开始例子中的python构造器了
我们最开始在定义函数outer的时候，估摸着会传入一个函数，然后在outer函数内部重新定义了一个新的函数inner，在inner函数内部不仅调用了传入的函数，更是增加了新的代码(print("fun5_in_fun4"))，并且还有新的返回值(return 'function in fun4')。
更重要的是在outer函数中把内部函数inner通过返回值的方式返回
我们在调用函数outer的时候也就通过变量s接受了outer的返回值，接下里调用s，并接受返回值。

通过这样一个过程我们便熟悉了python装饰器的原理，这里我们便可以重新倒回去看，文章最开始的例子了。

我们在执行文件test.py，调用s.f1()，这里调用的f1，已经不是前的f1了，从以上的分析中我们可以得知，其实这里调用的就是outer函数的内部函数inner了。
至于为什么调用的函数为什么不是原来的f1 而是内部函数inner那这就要关系到@outer了，@outer的功能也就是把f1函数替换为内部函数inner

接下来我们详细说一说@outer的具体功能：

首先@outer的用法是：用符号@+函数名并放在一个函数定义的前面
@outer有两个主要的功能：

1. 自动的执行outer函数，并把下面的函数f1当作参数传递给函数outer
   修改文件s.py如下：

def outer(func):
    print('before')
    print(func)
    def inner():
        print('hello world!')
        return func()
    return inner

@outer
def f1():
    print('f1')

然后运行文件s.py然后看到输出了字符串before，<function f1 at 0x10f2cfd08>

1. 将outer函数的返回值重新赋值给f1
   重新修改文件s.py如下所示：

def outer(func):

    return 'return' #  把返回值赋值给f1

@outer
def f1():
    print('f1')

print(f1)

运行s.py可知，打印出了'return'字符串。

python装饰器的参数传递

看这样一个例子：
修改文件s.py如下所示：

def outer(func):
    def inner():     # 没有参数
        ret = func()   # 没有参数
        print('hello')
        return ret
    return inner


@outer
def f1(a):     # 有一个参数 a
    print('a:',a)
    return 'f1'

修改文件test.py如图所示：

import s

s.f1(1)

执行test.py文件，但是报错了。这是为什么呢？
我们先根据原理分析下，在test.py文件中到我们调用s.py文件中的f1函数时，实际上是调用的函数inner，观察源代码，可以发现inner函数并没有参数，但是在调用的时候却传递给了一个参数，故就报错了，那怎么解决这个问题呢？
如果是缺少参数，那我们在inner函数中加上参数就行了。修改s.py中的代码如下：

def outer(func):
    def inner(arg):
        ret = func(arg)
        print('hello')
        return ret
    return inner


@outer
def f1(a):
    print('a:',a)
    return 'f1'

这样我们再运行test.py文件就不会报错了，但是这样还是会有问题！
在s.py文件中增加一个函数f2,如下所示：

def outer(func):
    def inner(arg):
        ret = func(arg)
        print('hello')
        return ret
    return inner


@outer
def f1(a):
    print('a:',a)
    return 'f1'


@outer
def f2(a,b,c):
    print('a:',a,' b:',b," c:",c)
    return 'f1'

接着在test.py中调用f2函数，修改test.py文件如下：

import s

s.f1(1)
s.f2(1,2,3)

然后运行test.py则还是会报一个参数错误，在f1中只有一个参数，而f2中则有三个参数，这应该怎么觉得呢？
这里肯定是不能修改原函数f1和f2的，那就只有修改outer函数了，既然是参数问题，就自然应该是inner函数出了问题，这里就应该是修改inner函数的参数了，这里就应该用python中的万能参数了。
修改s.py 文件如下所示：

def outer(func):
    def inner(*args, **kwargs):    # 使用python的万能参数
        ret = func(*args, **kwargs)
        print('hello')
        return ret
    return inner


@outer
def f1(a):
    print('a:',a)
    return 'f1'


@outer
def f2(a,b,c):
    print('a:',a,' b:',b," c:",c)
    return 'f1'

python装饰器的应用范围

从以上讲解我们明白了装饰器的执行原理，装饰器的功能是修饰一个函数，也就是当我们休要在某个函数体运行之前或者是运行之后添加某个功能，而不用修改原函数，那我们就可以使用python的装饰器。