三. 函数进阶(装饰器)二

一. 装饰器

装饰器
装饰器的作用
装饰器的固定模式

装饰器意思在已有的功能上  添加新功能但是不能修改原有的功能

# 简单的函数装饰器
def fun1():
 print("哈哈哈哈哈哈name")
def fun2():
   print("啦啦啦啦啦啦啦")
   fun1()
fun2()

# 啦啦啦啦啦啦啦
# 哈哈哈哈哈哈name

import  time
def aa():
    start=time.time()
    print("啦啦啦啦啦啦啦啦啦啦啦啦啦")
    time.sleep(2)
    end=time.time()
    cc=end-start
    return  cc,"执行时间"
d=aa()
print(d)

# 啦啦啦啦啦啦啦啦啦啦啦啦啦
# # (2.038980722427368, '执

# 简单装饰器
import  time
def gg(ll):
    start=time.time()
    ll()
    end = time.time()
    lo=end-start
    print(lo)
    
def ff():
    time.sleep(3)
    print("啦啦啦啦啦啦啦啦啦啦啦啦啦")
gg(ff)

# 啦啦啦啦啦啦啦啦啦啦啦啦啦
# 3.0006630420684814

# 装饰器意思在已有的功能上  添加新功能但是不能修改原有的功能
import  time
def fun():
    time.sleep(4)
    print("哈哈哈哈哈哈哈啊哈")

def b(f):          # 装饰器函数
    def c():
        start=time.time()
        f()   # 被装饰的函数
        end=time.time()
        print(end-start)
    return  c
a=b(fun)
a()
# 哈哈哈哈哈哈哈啊哈
# # # 4.000654458999634

1 .@语法糖 装饰器  return

import  time
# 装饰器意思在已有的功能上  添加新功能但是不能修改原有的功能
def b(f):          # 装饰器函数
    def c():
        start=time.time()
        f()   # 被装饰的函数
        end=time.time()
        print(end-start)
    return  c

@b          #语法 糖@装饰器函数名           # b=b(fun)     等于@b           # b()

def fun(): # 被装饰的函数
    time.sleep(4)
    print("哈哈哈哈哈哈哈啊111哈")
fun()

# 哈哈哈哈哈哈哈啊111哈
# 4.005651235580444

# 被装饰的函数带有返回值的 装饰函数
import time
def b(f):          # 装饰器函数
    def c():
        start=time.time()
        ret=f()   # 被装饰的函数
        end=time.time()
        print(end-start)
        return  ret
    return  c
@b                # # b=b(fun)     等于@b 语法 糖@装饰器函数名
def fun(): # 被装饰的函数
    time.sleep(4)
    print("哈哈哈哈哈哈哈啊11111111111111111哈")
    return "我来学习python"
aa=fun()
print(aa)

# 哈哈哈哈哈哈哈啊11111111111111111哈
# 4.014800548553467
# 我来学习python

# 被装饰的函数带参数的装饰器
import  time
def b(f):          # 装饰器函数
    def c(a):
        start=time.time()
        ret=f(a)   # 被装饰的函数
        end=time.time()
        print(end-start)
        return  ret
    return  c
@b          # # b=b(fun)     等于@b 语法 糖@装饰器函数名
def fun(a): # 被装饰的函数
    time.sleep(4)
    print("哈哈哈哈哈哈哈",a)
    return "我来学习python"
aa=fun(99999999)
print(aa)

# 哈哈哈哈哈哈哈 99999999
# 4.005716800689697
# 我来学习python

2 .@语法糖 装饰器  return   参数*arg ，**kwargs

import  time
# 被装饰的函数带参数的装饰器
def b(f):          # 装饰器函数
    def c(*args,**kwargs):
        start=time.time()
        ret=f(*args,**kwargs)   # 被装饰的函数
        end=time.time()
        print(end-start)
        return  ret
    return  c


@b          # # b=b(fun)     等于@b 语法 糖@装饰器函数名
def fun(a): # 被装饰的函数
    time.sleep(4)
    print("哈哈哈哈哈哈哈",a)
    return "我来学习php11111"
bb=fun(99999999)
print(bb)


@b          # # b=b(fun)     等于@b 语法 糖@装饰器函数名
def fun1(c,d): # 被装饰的函数
    time.sleep(3)
    print("啦啦啦啦啦啊啦里",c,d)
    return "我来学习python2222"
aa=fun1(10000,2000000)
print(aa)

#
# 我来学习php11111
# 啦啦啦啦啦啊啦里 10000 2000000
# 3.008254289627075
# 我来学习python2222

import  time
# 被装饰的函数带参数的装饰器
def b(f):          # 装饰器函数
    def c(*args,**kwargs):
        start=time.time()
        f(*args,**kwargs)   # 被装饰的函数
        end=time.time()
        print(end-start)

    return  c

@b          # # b=b(fun)     等于@b 语法 糖@装饰器函数名
def fun(a): # 被装饰的函数
    time.sleep(4)
    print("哈哈哈哈哈哈哈",a)
fun(99999999)


@b          # # b=b(fun)     等于@b 语法 糖@装饰器函数名
def fun1(c,d): # 被装饰的函数
    time.sleep(3)
    print("啦啦啦啦啦啊啦里",c,d)
fun1(10000,2000000)

 3. 装饰器固定模板

# 装饰模板
def wrapper(f):  #  f参数代表被装饰的函数
    def inner(*args,**kwargs):
         # 在装饰函数之前要做的事情
         ret= f(*args,**kwargs)
         # 在装饰函数之后要做的事情
         return  ret
    return  inner

@wrapper

def aa(a):
    print("11111111",a)
    return  "我要吃冰淇淋"
dd=aa(2)
print(dd)

def outer(f):
    def inner(*args,**kwargs):
         ret= f(*args,**kwargs)
         return  ret
    return inner

@outer
def aa(*args):
    print("aaaa",args)
    return "我是被装饰的函数"
b=aa(1,666666,999,5555)
print(b)

4.python提供的装饰器  带参数

# 这是python提供的装饰器  带参数
from functools import wraps

def wrapper(fun):
     @wraps(fun)    #   这是python提供的装饰器  带参数 但是不影响自己定义的装饰器
     def inner(*args,**kwargs):
        ret=fun(*args,**kwargs)
        return ret
     return  inner

@wrapper
def fun(aa):
    '''这是一个放假通知'''
    print("全体放假%s三天"%aa)
    return  "好几把爽哈哈哈哈"
print(fun.__name__)
print(fun.__doc__)
c=fun(3)
print(c)

#
# fun
# 这是一个放假通知
# 全体放假3三天
# 好几把爽哈哈哈哈

5.最多三层装饰器
  假如你要执行500行代码都加了装饰器    需要执行就True 不执行就False

# 假如说你有500
import time
def timer(func):
    def inner(*args,**kwargs):
        start=time.time()
        ret=func(*args,*kwargs)
        end=time.time()
        print(end-start)
        return  ret
    return inner

@timer
def aa():
    time.sleep(3)
    print("拉拉拉啊啦啦啦")
    return "执行时间"
aa=aa()
print(aa)

# 拉拉拉啊啦啦啦
# 3.000779151916504
# 执行时间

# # 最多三层装饰器
# # 假如你要执行500行代码都加了装饰器    需要执行就True 不执行就False
FALG=True
import time
def timer_out(flag):
    def timer(func):
        def inner(*args,**kwargs):
          if flag:
                start=time.time()
                ret=func(*args,*kwargs)
                end=time.time()
                print(end-start)
                return  ret
          else:
                ret = func(*args, *kwargs)
                return ret
        return inner
    return timer
@timer_out(FALG)          #@timer_out(FALG) ===> aa=timer(aa)
def aa():
    time.sleep(3)
    print("拉拉拉啊啦啦啦")
    return "执行时间"
a=aa()
print(a)


# 拉拉拉啊啦啦啦
# 3.0071675777435303
# 执行时间

# 多个装饰器 装饰一个函数
def wrapper1(fun):     #  fun -->aa
     def inner1():
         print("11111111111111111装饰器1")
         fun()    #  aa
         print("22222222222222222装饰器1")
     return  inner1


def wrapper2(fun):   # fun ->inner1
    def inner2():
        print("33333333333333装饰器2")
        fun()     # inner1()
        print("444444444444444装饰器2")
    return inner2


@wrapper2         #  aa=wrapper2(aa)  =wrapper2(inner1)=inner2
@wrapper1        # aa=wrapper1(aa)   =inner1


def aa():
    print("啦啦啦啦啦啦啦")
aa()    #  inner2()


# 11111111111111111装饰器1
# 啦啦啦啦啦啦啦
# 22222222222222222装饰器1
# 444444444444444装饰器2

# 多个装饰器 装饰一个函数
def wrapper1(fun):     #  fun -->aa
     def inner1(*args,**kwargs):
         print("11111111111111111装饰器1")
         ret=fun(*args,**kwargs)    #  aa
         print("22222222222222222装饰器1")
         return ret
     return  inner1
def wrapper2(fun):   # fun ->inner1
    def inner2(*args,**kwargs):
        print("33333333333333装饰器2")
        ret=fun(*args,**kwargs)     # inner1()
        print("444444444444444装饰器2")
        return ret
    return inner2
@wrapper2         #  aa=wrapper2(aa)  =wrapper2(inner1)=inner2
@wrapper1        # aa=wrapper1(aa)   =inner1
def aa(a,b):
    print("啦啦啦啦啦啦啦",a,b)
    return "我是多个装饰器"
bb=aa(1,[22,33])    #  inner2()
print(bb)

# 33333333333333装饰器2
# 11111111111111111装饰器1
# 啦啦啦啦啦啦啦 1 [22, 33]
# 22222222222222222装饰器1
# 444444444444444装饰器2
# 我是多个装饰器

import time
Flag=True
def log(flag):
    def swup(func):
        def inner(*args,**kwargs):
            if flag:
                start=time.time()
                ret=func(*args,**kwargs)
                end = time.time()
                print(end-start)
                return  ret
            else:
                ret = func(*args, **kwargs)
                return ret
        return inner
    return swup

@log(Flag)
def aa():
    time.sleep(6)
    print(1111111)
aa()

@log(Flag)
def bb():
    time.sleep(2)
    print(2222222)
bb()

# 1111111
# 6.0156004428863525
# 2222222
# 2.0006721019744873

# 装饰器登陆
FAL=False
def login(fun):
    def inner(*args,**kwargs):
        global FAL
        if FAL:
            ret = fun(*args, **kwargs)
            return ret
        else:
            name=input("输入用户名:")
            pw=input("输入密码:")
            if name=="lover"and pw=="123":
                FAL=True
                ret=fun(*args,**kwargs)
                return  ret
            else:
                print("登陆失败")
    return  inner
@login
def shopping():
    print("我要买一件商品")
@login
def delto():
    print("我要删除一件商品!!1")
shopping()
delto()

# 装饰器函数监听执行
def wr(fun):
    def inner(*args,**kwargs):
        with open("cc.txt","a",encoding='utf-8')as  f1:
            ret=fun(*args,**kwargs)
            f1.write(fun.__name__+'
')
            return  ret
    return  inner


@wr
def cc():
    print("11111111111111")
    return "的大块大块"
cc()


@wr
def jj():
    print("11111111111111")
    return "的大块大块"
jj()

def aa(fun):
     def bb(*args,**kwargs):
           if os.path.getsize('web.txt'):
               with open('web.txt','rb')as f:
                    return  f.read()
           ret=fun(*args,**kwargs)
           with open('web.txt', 'wb')as f1:
                f1.write(ret)
           return ret
     return  bb

@aa
def get_url(url):
    code=urlopen(url).read
    return  code
ret=get_url('https://www.baidu.com')
print(ret)

ret=get_url('http://huaban.com/favorite/beauty')
print(ret)

from functools import wraps
# 这个模块是python内部提供的 装饰器 包装模块   添加上对自己的装饰器不会有影响
# 装饰器（decorator）是干嘛的？对于受到封装的原函数来说，装饰器能够在那个函数执行前或者执行后分别运行一些代码，
# 使得可以再装饰器里面访问并修改原函数的参数以及返回值，以实现约束定义、调试程序、注册函数等目标。装
# 饰器一般返回一个包装器（wrapper），而functools.wraps就是装饰包装器的装饰器。

lissrt=[
    {"user":"aaa","pwd":"1"},
    {"user": "bbb", "pwd": "111"}
]
loglist={"username":None,"login":False}
def swp(fun):
   @wraps(fun)
   def inner(*args,**kwargs):
       if loglist["username"]!=None and loglist["login"]==True:
           ret = fun(*args, **kwargs)
           return  ret

       aa=input("请输输入用户名").strip()
       pw=input("请输入密码").strip()
       for user in  lissrt:
         if aa==user["user"] and pw==user["pwd"]:
            ret=fun(*args,**kwargs)
            loglist["username"]=aa
            loglist["login"]=True
            return  ret
         else:
             print("你输入的密码错误了啊哈哈哈")
             break
   return  inner
@swp       #    相当于    shopping=swp(shopping)
def shopping():
     print("登陆成功了哈哈哈")
shopping()
@swp
def shopping():
     print("登陆成功111了哈哈哈")
shopping()
@swp
def shopping():
     print("登陆成功111了哈哈哈")
shopping()
print(shopping.__name__)  #查看函数名的方法