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 == '123':
                    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')