day3-python之装饰器(四)

一、简单的装饰器

装饰器本质上就是一个python函数，可以让其他函数在不需要任何代码变动的前提下，增加额外的功能，装饰器的返回值也是一个函数对象。

简单来讲，在原有的函数前后增加功能，且不改变原函数的调用方式。

装饰器的本质：就是一个闭包函数

装饰器的应用场景：插入日志、性能测试、事务处理、缓存等等场景。

实现计算每个函数的执行时间的功能：

import time
def timmer(f):
    def inner():
        start_time = time.time()
        f()
        end_time = time.time()
        print(end_time - start_time)
    return inner

def func():
    print('begin func')
    time.sleep(0.1)
    print('end func')

func = timmer(func)
func()   # ==> inner()

以上功能不简洁，不完美。引出语法糖。

import time
def timmer(f):
    def inner():
        start_time = time.time()
        f()
        end_time = time.time()
        print(end_time - start_time)
    return inner

@timmer   # ==>  func = timmer(func)
def func():
    print('begin func')
    time.sleep(0.1)
    print('end func')

func()   # ==> inner()

以上装饰器都是不带参数函数，现在装饰一个带参数的该怎么办？

import time
def timmer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)
        end_time = time.time()
        print(end_time - start_time)
        return ret
    return inner

@timmer   # ==>  func = timmer(func)
def func(a,b):
    print('begin func',a)
    time.sleep(0.1)
    print('end func',b)
    return True

func(1,2)   # ==> inner()

import time

def timer(func):
    def inner(a):
        start = time.time()
        func(a)
        print(time.time() - start)
    return inner

@timer
def func1(a):
    print(a)

func1(1)

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        end=time.time()
        print(end- start)
        return re
    return inner

@timer   #==> func1 = timer(func1)
def func1(a,b):
    print('in func1')
    print(a,b)

@timer   #==> func1 = timer(func1)
def func2(a):
    print('in func2 and get a:%s'%(a))
    return 'fun2 over'

func1(1,2)
print(func2('aaaaaa'))

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        end=time.time()
        print(end - start)
        return re
    return inner

@timer   #==> func1 = timer(func1)
def jjj(a):
    print('in jjj and get a:%s'%(a))
    return 'fun2 over'

jjj('aaaaaa')
print(jjj('aaaaaa'))

二、开放封闭原则

1.对扩展是开放的
任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。
2.对修改是封闭的
因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。
装饰器完美的遵循了这个开放封闭原则。

三、装饰器的固定结构

def timmer(f):
    def inner(*args,**kwargs):
        '''执行函数之前要做的'''
        ret = f(*args,**kwargs)
        '''执行函数之后要做的'''
        return ret
    return inner

四、带参数的装饰器

带参数的装饰器：就是给装饰器传参

用处：就是当加了很多装饰器的时候，现在忽然又不想加装饰器了，想把装饰器给去掉，但是那么多代码，一个一个去显得麻烦，所以，可以利用带参数的装饰器去装饰它，就像一个开关，需要的时候就打开调用，不需要的时候就关闭去掉。给装饰器里面传个参数，那么这个语法糖也要带个括号。在语法糖括号内传参。可以用三层嵌套，弄一个标识

# 带参数的装饰器：（相当于开关）为了给装饰器传参
F=True#为True时就把装饰器给加上了
# F=False#为False时就把装饰器给去掉了
def outer(flag):
    def wrapper(func):
        def inner(*args,**kwargs):
            if flag:
                print('before')
                ret=func(*args,**kwargs)
                print('after')
            else:
                ret = func(*args, **kwargs)
            return ret
        return inner
    return wrapper

@outer(F)#@wrapper
def hahaha():
    print('hahaha')

@outer(F)
def shuangwaiwai():
    print('shuangwaiwai')

hahaha()
shuangwaiwai()

五、多个装饰器装饰一个函数

def qqqxing(fun):
    def inner(*args,**kwargs):
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')
        return ret
    return inner

def pipixia(fun):
    def inner(*args,**kwargs):
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')
        return ret
    return inner
@qqqxing
@pipixia
def dapangxie():
    print('饿了吗')
dapangxie()

'''
@qqqxing和@pipixia的执行顺序：先执行qqqxing里面的 print('in qqxing: before')，然后跳到了pipixia里面的
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')，完了又回到了qqqxing里面的 print('in qqxing: after')。所以就如下面的运行结果截图一样
'''

 六、进阶需求

第一种情况：

# 500个函数

# 设计你的装饰器 从而确认是够生效

import time
def outer(flag):
    def timmer(f):
        def inner(*args,**kwargs):
            if flag == True:
                start_time = time.time()
                ret = f(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
            else:
                ret = f(*args,**kwargs)
            return ret
        return inner
    return timmer

@outer(False)
def func(a,b):
    print('begin func',a)
    time.sleep(0.1)
    print('end func',b)
    return True

func(1,2)

 第二种情况：

# 装饰器：登录、记录日志

login_info = {'alex':False}
def login(func):
    def inner(name):
        if login_info[name] != True:
            user = input('user:')
            pwd = input('pwd:')
            if user == 'alex' and pwd == 'alex3714':
                login_info[name] = True
        if login_info[name] == True:
            ret = func(name)
            return ret
    return inner

@login
def index(name):
    print('欢迎%s来到博客园首页~' %name)

@login
def manager(name):
    print('欢迎%s来到博客园管理页~' %name)

index('alex')
index('alex')
manager('alex')
manager('alex')

import time
login_info = {'alex':False}
def login(func):   # manager
    def inner(name):
        if login_info[name] != True:
            user = input('user ：')
            pwd = input('pwd ：')
            if user == 'alex' and pwd == 'alex3714':
                login_info[name] = True
        if login_info[name] == True:
            ret = func(name)     # timmer中的inner
            return ret
    return inner

def timmer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)     # 调用被装饰的方法
        end_time = time.time()      #
        print(end_time - start_time)
        return ret
    return inner

@login
@timmer
def index(name):
    print('欢迎%s来到博客园首页~'%name)

@login
@timmer    # manager = login(manager)
def manager(name):
    print('欢迎%s来到博客园管理页~'%name)

index('alex')
index('alex')
manager('alex')
manager('alex')

l=[]
def wrapper(fun):
    l.append(fun)#统计当前程序中有多少个函数被装饰了
    def inner(*args,**kwargs):
        # l.append(fun)#统计本次程序执行有多少个带装饰器的函数被调用了
        ret = fun(*args,**kwargs)
        return ret
    return inner

@wrapper
def f1():
    print('in f1')

@wrapper
def f2():
    print('in f2')

@wrapper
def f3():
    print('in f3')
print(l)

 

七、总结

# 装饰器的进阶
    # 给装饰器加上一个开关  - 从外部传了一个参数到装饰器内
    # 多个装饰器装饰同一个函数 - 套娃
        # 每个装饰器都完成一个独立的功能
        # 功能与功能之间互相分离
        # 同一个函数需要两个或以上额外的功能

def wrapper1(func):
    def inner(*args,**kwargs):
        '''执行a代码'''
        ret = func(*args,**kwargs)
        '''执行b代码'''
        return ret
    return inner

def wrapper2(func):
    def inner(*args,**kwargs):
        '''执行c代码'''
        ret = func(*args,**kwargs)
        '''执行d代码'''
        return ret
    return inner

@wrapper1
@wrapper2
def func():pass