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

# 简单的函数装饰器
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

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

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)

# 装饰模板
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)