day04-函数，装饰器初成

 面试的时候，经常被问过装饰器，所以掌握好装饰器非常重要。
 一.装饰器形成的过程：1.最简单的装饰器。2.被装饰的函数有返回值。3.被装饰的函数有一个参数。4.被装饰的函数有多个位置参数。5.被装饰的函数有多个位置参数和关键字参数。
 二.装饰器的作用：不修改被装饰的函数的代码和调用方式，增加新的功能。
 三.原则：开放封闭原则。
 四.语法糖：@wrapper
 五.装饰器的固定模式。

 一.装饰器形成的过程：1.最简单的装饰器。注意：下面代码没修改被装饰的函数的代码，但是调用使用了timmer(test)而不是test(),改变了调用方式，会导致
                                      以前调用该函数的程序发生错误(如果以前有人使用过你写的函数)。
 使用 时间函数 计算 代码 运行的时间
 import time
 def timmer(t):                                                  #timmer(t)是时间装饰器
     start = time.time()     #开始：函数开始运行的时间
     time.sleep(0.01)        #让函数睡眠0.01秒，否则打印的结果是0.0。
     t()                     #过程：函数运算的过程。t()表示调用被装饰的函数。
     end = time.time()       #结束：函数结束运行的时间
     print(end-start)        #打印出运算的过程需要多少时间
 def test():
     print('今天必须非常努力，我要寻找热爱学习热爱工作的自己，我会为自己的努力而感到快乐幸福和满足')
 timmer(test)        #把需要计算运行时间的函数对象(或者说是地址)传给时间函数timmer

 1.在不准修改test函数的情况下，装饰器发挥非常重要的作用：不修改test函数的代码，那么调用test函数的方式也不能修改，但是想在函数前后增加功能。
 2.下面例子，test()这种调用函数的方式没有改变，但是给test函数增加了计算运行时间的功能。
 3.开放封闭原则：对拓展(增加功能)是开放的，但是对修改被装饰的函数是封闭的。

 一.装饰器形成的过程：1.最简单的装饰器：不修改被装饰的函数的代码和调用方式，使用了内部函数和闭包。
 import time
 def timmer(f):              #装饰器函数
     def inner():
         start = time.time()
         time.sleep(0.01)
         f()                 #被装饰的函数
         end = time.time()
         print(end-start)
     return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
 test = timmer(test)
 def test():
     print('今天必须非常努力，我要寻找热爱学习热爱工作的自己，我会为自己的努力而感到快乐和幸福和满足')
 test()                 #test()=inner()

 #一.装饰器形成的过程：2.被装饰的函数有返回值。
 import time
 def timmer(f):              #装饰器函数
     def inner():
         start = time.time()
         time.sleep(0.01)
         n = f()                 #被装饰的函数
         end = time.time()
         print(end-start)
         return n
     return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
 test = timmer(test)
 def test():                  #被装饰的函数
     print('今天必须非常努力，我要寻找热爱学习热爱工作的自己，我会为自己的努力而感到快乐和幸福和满足')
     return 10000000
 print(test())           #test()=inner()

 #一.装饰器形成的过程：3.被装饰的函数有一个参数。
 import time
 def timmer(f):              #装饰器函数
     def inner(a):
         start = time.time()
         time.sleep(0.01)
         n = f(a)                 #被装饰的函数
         end = time.time()
         print(end-start)
         return n
     return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
 test = timmer(test)
 def test(a):               #被装饰的函数
     print('加油',a)
     return 10000000
 print(test(10000000))           #test(a)=inner(a)

 一.装饰器形成的过程：4.被装饰的函数有多个位置参数。
 import time
 def timmer(f):              #装饰器函数
     def inner(*args):
         start = time.time()
         time.sleep(0.01)
         n = f(*args)                 #被装饰的函数
         end = time.time()
         print(end-start)
         return n
     return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
 test = timmer(test)
 def test(*args):          #被装饰的函数
     print('加油',args)
     return 10000000
 print(test(1,2,3))           #test(*args)=inner(*args)

 #一.装饰器形成的过程：5.被装饰的函数有多个位置参数和关键字参数。
 import time
 def timmer(f):              #装饰器函数
     def inner(*args,**kwargs):
         start = time.time()
         time.sleep(0.01)
         n = f(*args,**kwargs)                 #被装饰的函数
         end = time.time()
         print(end-start)
         return n
     return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
 test = timmer(test)
 def test(*args,**kwargs):          #被装饰的函数
     print('加油',args,kwargs)
     return 10000000
 print(test(1,2,3,t=8000000,m=10000000))           #test(*args,**kwargs)=inner(*args,**kwargs)

 四.语法糖：@wrapper
 import time
 def timmer(f):
     def inner():
         start = time.time()
         time.sleep(0.01)
         n = f()
         end = time.time()
         print(end - start)
　　　　　　　return n
     return inner
 @timmer            #语法糖@timmer相当于 func=timmer(func)  没有语法糖或func=timmer(func)，装饰器就无法起作用。
 def func():
     print('今天继续加油')
 func()

 五.装饰器的固定模式。wrapper是装饰的意思。
 def wrapper(f):
     def inner(*args,**kwargs):
         '''在被装饰的函数前面增加功能'''
         ret = f(*args,**kwargs)
         '''在被装饰的函数后面增加功能'''
         return ret
     return inner                            #上面五句话是装饰器的固定模式。
 @wrapper
 def func(*args,**kwargs):
     return args,kwargs
 print(func(1,2,3,m=10000000))

 六.装饰器的执行过程：
 1. def wrapper(f):
   4. def inner(*args,**kwargs):
      7. '''在被装饰的函数前面增加功能'''
      8.  ret = f(*args,**kwargs)
      9.  '''在被装饰的函数后面增加功能'''
      10.  return ret               #返回func(1,2,3,m=10000000)的返回值，因为第6步使用了print，所以被装饰的函数的返回值就被打印出来。
   5. return inner               #返回inner给wrapper(func),那么inner=wrapper(func)=func
 3. @wrapper                   #func=wrapper(func)传参
 2. def func(*args,**kwargs):
     return args,kwargs
 6. print(func(1,2,3,m=10000000))   #func=inner,相当于print(inner(1,2,3,m=10000000)),接着内部函数inner执行。
                                      调用func函数实际上是调用了装饰器的内部函数：inner函数。