python全栈开发从入门到放弃之装饰器函数

什么是装饰器
#1  开放封闭原则：对扩展是开放的，对修改是封闭的
#2 装饰器本身可以是任意可调用对象，被装饰的对象也可以是任意可调用对象
#3 目的：
'''
    在遵循
        1. 不修改被装饰对象的源代码
        2. 不修改被装饰对象的调用方式
    原则下
    为被装饰对象加上新功能
'''

1、函数名可以当作函数的参数

 import time
 def timmer(func):
     #函数名可以当做函数的参数
     def inner():
         start = time.time()
         func()
         end = time.time()
         print(end - start)
     return inner

 def hahaha():
     time.sleep(0.1)
     print('aaaa')

 hahaha()

 输出结果
 aaaa

2、假如我们不能修改这个函数的调用方式，也不能修改原代码，该怎么做到呢

 import time
 def timmer(func):
     #函数名可以当做函数的参数
     def inner():
         start = time.time()
         func()
         end = time.time()
         print(end - start)
     return inner

 def hahaha():
     time.sleep(0.1)
     print('aaaa')

 hahaha = timmer(hahaha)       #timmer函数的地址给了hahaha  然后在进行调用
 hahaha()

 aaaa
 0.10033607482910156

# hahaha = timmer(hahaha) #timmer函数的地址给了hahaha
# hahaha() #实际上执行的是timmer

3、函数传参

 def timmer(func):  #---> hahaha
     def inner(*args,**kwargs):         #动态参数接收从kkk传来的1，2并进行压缩成元组
         #args == (1,2)  kwargs == {}
         #*args == 1,2   **kwargs == a =1,b = 2
         func(*args,**kwargs)  # ---》kkk   #func把值传给kkk并还原，实际上就是解压之前动态参数接收的压缩的值，返回给kkk函数
     return inner

 def kkk(a,b):
     print(a)

 kkk = timmer(kkk)     #timmer函数里的func是kkk函数，然后返回inner函数给kkk
 kkk(1,2)      #kkk函数调用并传参给inner（动态参数*args），       

 1

参数
#实参：调用函数的时候传入的参数
#形参
#位置参数:必须传值

 def aaa(a,b):
 print(a,b)
 aaa(1,2)

#默认参数：可以不传

 def bbb(x=10):      #默认参数 没上传参数的话用默认的参数，上传的话会用上传的参数。
 print(x)
 bbb() #x = 10
 bbb(20) #x = 20

#动态参数

 def ccc(*args):#1,2,3,4,5     #*args  会将ccc上传的参数以元组的方式存放
 print(args)

 ccc(1,2,3,4,5)#按位置传参数

解压传参

 def ccc(*args):#1,2,3,4,5
     print(args)

 #ccc(1,2,3,4,5)#按位置传参数

 t = (1,2,3,4,5)
 ccc(t) # ((1, 2, 3, 4, 5),)
 ccc(*t)  #(1, 2, 3, 4, 5)   #解压

按关键字传参

 def ddd(**kwargs):   #kwargs接收传参然后以字典的方式存放
     print(kwargs)

 ddd(k = 'a',j = 'b')#按关键字传参数

打散赋值

 def ccc(*args):
     print('ccc:',args)  #(1,2,3,4,5)
     def inner(a,b,c,d,e):
         print('inner',a,b,c,d,e)
     inner(*args)  #*(1,2,3,4,5)  打散

 def inner(a,b,c,d,e):     #接收解压的参数然后一一赋值
     print('inner',a,b,c,d,e)
 ccc(1,2,3,4,5)
 inner(1,2,3,4,5)

4、语法糖

 def timmer(func):  #---> jjj
     def inner(*args,**kwargs):
         ret = func(*args,**kwargs)  # --->ret = jjj()
         print(ret)
         return ret
     return inner

 @timmer  #jjj = timmer(jjj)  语法糖
 def jjj():
     return 123

 jjj()     #ret = jjj()

 输出结果
 123

5、装饰器函数

#装饰器的本质 ：闭包函数
#功能：就是在不改变原函数调用方式的情况下，在这个函数前后加上扩展功能
def timmer(func):
def inner(*args,**kwargs):
'''添加函数调用之前的扩展代码'''
ret = func(*args,**kwargs)
'''添加函数调用之后的扩展代码'''
return ret
return inner
#设计模式 原则 开放封闭原则
#对扩展是开放的
#对修改是封闭的

6、装饰器装饰两个函数

 def wrapper(func):#装饰
     def inner(*args,**kwargs):

         ret = func(*args,**kwargs)

         return ret
     return inner

 @wrapper        #aaa = wrapper(aaa)
 def aaa():
     print('asghksdlhf')

 @wrapper        #bbb = wrapper(bbb)
 def bbb():
     print('asghksdlhf')

 aaa()
 bbb()

 #输出结果：
 #asghksdlhf
 #asghksdlhf

7、有参装饰器

import time

def auth(auth_type): #auth_type='mysql'
    def auth2(func):
        def inner(*args,**kwargs):
            if auth_type == 'file':
                name=input('name:>> ')
                pwd=input('password:>> ')
                if name == 'egon' and pwd == '':
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('auth error')
            elif auth_type == 'mysql':
                print('mysql auth')
            else:
                print('not valid auth source')
        return inner
    return auth2

@auth(auth_type='mysql') #@auth2 #index=auth2(最原始的index) #index=inner
def index(name):
    time.sleep(3)
    print('welcome %s to index' %name)

index('egon') #inner('egon')