十九、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