十九、python沉淀之路--装饰器

一、实现装饰器的预备知识

装饰器 = 高阶函数 + 函数嵌套 + 闭包

1、高价函数定义：

    1.函数接收的参数是一个函数名
    2.函数的返回值是一个函数名
    3.满足上述条件任意一个,都可称之为高阶函数

例1：铺垫

import time
#例1
def fn():
    print('这是被调用函数')
    time.sleep(2)

def test(func):
    print('高阶函数将要开始运行')
    start_time = time.time()
    func()
    end_time = time.time()
    print('被调用函数的运行时间%s'%(end_time - start_time))

test(fn)

例2

#例2
import time
def fn():
    print('这是被调用函数')
    time.sleep(2)
def test(func):
    print('正在执行高阶函数')
    return func
#第一种调用
f = test(fn)
print(f)
f()

## 第二种调用，升级版 ：将调用函数test(func)的返回值赋值给一个与被调用函数fn()同名的变量fn，最后实现的效果就是
                      #（1）不改变被调用函数fn()的源代码
                      #（2） 不改变被调用函数fn()的调用方式
fn = test(fn)
print(fn)
fn()

正在执行高阶函数
<function fn at 0x0000017065C999D8>
这是被调用函数
正在执行高阶函数
<function fn at 0x0000017065C999D8>
这是被调用函数

升级版 ：将调用函数test(func)的返回值赋值给一个与被调用函数fn()同名的变量fn，最后实现的效果就是
                      （1）不改变被调用函数fn()的源代码
                      （2） 不改变被调用函数fn()的调用方式

 例3  这种情况出现的结果是 多运行了一行

# 例3
import time
def fn():
    print('这是被调用函数')
    time.sleep(2)

def test(func):
    print('开始执行调用函数')
    start_time = time.time()
    func()
    end_time = time.time()
    return func      # 这种情况出现的结果是 多运行了一行

fn = test(fn)
fn()

开始执行调用函数
这是被调用函数
这是被调用函数

例4

#例4
def fn():
    print('这是被调用函数')
def test(func):
    print('正在执行高阶函数')
    res = func()
    print('被调用函数执行完毕')
    return res

fn = test(fn)
# fn()     # 报错  ：TypeError: 'NoneType' object is not callable

正在执行高阶函数
这是被调用函数
被调用函数执行完毕

即使赋了一个值，也还是解决不了多打印一行的结果。所以单层函数解决不了这个问题

高阶函数总结：
1、函数接收的参数是一个函数名
    作用：在不修改函数源代码的前提下，为函数添加新功能。
    不足：会改变函数的调用方式。
2、函数的返回值是一个函数名：
    作用：不修改函数的调用方式
    不足：不能添加新功能。

二、嵌套函数

 定义：

def father(name):
    print('%s is from father'%name)
    def son():
        print('I am BeiJing,My fahter is %s'%name)
        def grandson():
            print('I am HaiDian,My grandfather is %s'%name)
        grandson()
    son()
    # print(locals())

father('china')

china is from father
I am BeiJing,My fahter is china
I am HaiDian,My grandfather is china

详解在我的另外一篇博客里面：http://www.cnblogs.com/jianguo221/p/8984618.html

三、实现装饰器（步骤进化）（重点中的重点）

#进化版############################################################3
import time
def outer(func):
    def inner():
        print('开始运行被测试函数')
        start_time = time.time()
        func()
        end_time = time.time()
        print('被测试函数的运行时间是：%s'%(start_time - end_time))
    return inner

def test():
    print('正在运行这个测试函数')
    time.sleep(2)
# 慢慢实现装饰器
#第一种调用方式
f = outer(test)     #这条语句返回的就是inner的地址，即函数体
f()

#第二种调用方式
inner = outer(test)    ##这条语句返回的就是inner的地址，即函数体
inner()
#由于第二种调用方式  和 第一种调用方式实现的效果是一样的。所以就满足了 装饰器的两个条件：
                     #（1）不改变被调用函数test()的源代码
                     #（2） 不改变被调用函数test()的调用方式
#继续过度：由于第二种方式满足了装饰器调用的两个条件，就可以用  装饰器的一个 语法糖  形式来替换第二种形式，
          #以便实现简便操作  ， 即加一个  @outer  .如下面的例子
#加语法糖
#终极版###################################
import time
def outer(func):
    def inner():
        print('开始运行被测试函数')
        start_time = time.time()
        func()
        end_time = time.time()
        print('被测试函数的运行时间是：%s'%(start_time - end_time))
    return inner
@outer
def test():
    print('正在运行这个测试函数')
    time.sleep(2)

#加了语法糖后，调用方式就简单很多，只需要这样写就好了。语法糖  @outer  就等价于  test =outer(test)
test()

运行结果：

开始运行被测试函数
正在运行这个测试函数
被测试函数的运行时间是：-2.000378370285034
开始运行被测试函数
正在运行这个测试函数
被测试函数的运行时间是：-2.0004947185516357
开始运行被测试函数
正在运行这个测试函数
被测试函数的运行时间是：-2.0002481937408447