1
2
3
4
5
运行时间：2.502134323120117

def foo():
    print(‘我的函数名作为参数传给高阶函数‘)
def gao_jie1(func):
    print(‘我就是高阶函数1,我接收的参数名是%s‘ %func)
    func()

def gao_jie2(func):
    print(‘我就是高阶函数2,我的返回值是%s‘ %func)
    return func

gao_jie1(foo)
gao_jie2(foo)

import time
def foo():
    print(‘from the foo‘)

def timmer(func):
    start_time=time.time()
    func()
    stop_time=time.time()
    print(‘函数%s 运行时间是%s‘ %(func,stop_time-start_time))
timmer(foo)
#总结:我们确实为函数foo增加了foo运行时间的功能,但是foo原来的执行方式是foo(),现在我们需要调用高阶函数timmer(foo),改变了函数的调用方式

import time
def foo():
    print(‘from the foo‘)

def timmer(func):
    start_time=time.time()
    return func
    stop_time=time.time()
    print(‘函数%s 运行时间是%s‘ %(func,stop_time-start_time))
foo=timmer(foo)
foo()
#总结:我们确实没有改变foo的调用方式,但是我们也没有为foo增加任何新功能

import time
def timmer(func):#func=test
    def wrapper(name,age):
        start_time = time.time()
        res=func(name,age)  # 就是在运行test()
        stop_time = time.time()
        print("函数运行时间的是%s" % (stop_time - start_time))
        return res
    return wrapper
# @timmer 等效于 test=timmer(test)
@timmer
def test(name,age):
    time.sleep(3)
    print(‘test函数运行完毕‘)
    return "这是test的返回值"
res=test("lingling",20)
print(res)


@timmer
# @timmer 等效于 test1=timmer(test1)
def test1(name,age,gender):
    time.sleep(3)
    print(‘test函数运行完毕‘)
    return "这是test1的返回值"
res=test1("lingling",20)
print(res)
#@timmer 等效于 test=timmer(test)，#在这里一定要注意，我们首先把test函数传入到timmer装饰器，我们下一步返回了wrapper函数的地址（return wrapper）。
#test变量接收到wrapper函数的地址
#test("lingling",20)传入参数，执行wrapper函数，这里test函数有参数，为name，age,所以wrapper函数也应该有两个变量name,age，而执行wrapper函数，实际是要执行test函数，此处也需要两个参数,name,age
#res变量接收到test函数执行的结果



# 1.将test函数传入timmer：timmer(test)
# 2.执行timmer函数，返回wrapper函数地址（return wrapper）
# 3.执行wrapper函数（执行wrapper函数实则是执行test函数）,并接收test函数返回值：res=test("lingling",20)

import time
def timmer(func):#func=test
    def wrapper(*wargs,**kwargs):
        start_time = time.time()
        res=func(*wargs,**kwargs)  # 就是在运行test()
        stop_time = time.time()
        print("函数运行时间的是%s" % (stop_time - start_time))
        return res
    return wrapper

@timmer
def test(name,age):
    time.sleep(3)
    print(‘test函数运行完毕‘)
    return "这是test的返回值"
res=test("lingling",age=20)
print(res)


@timmer
def test1(name,age,gender):
    time.sleep(3)
    print(‘test1函数运行完毕‘)
    return "这是test1的返回值"
res=test1("lingling",20,‘male‘)
print(res)

#解决wrapper不固定接收参数的问题
#如果细心可能会想，这里我们把wrapper参数写死了，你只能传入两个参数，如果有不同的函数需要这个装饰器，那我们不得重新修改装饰器，这真是一个大问题，我们来解决这个问题
#所以我们在wrapper函数中应该接收到test函数的所有参数：*wargs,**kwargs
# *wargs:接收所有位置参数
# **kwargs：接收键值对类型的参数
#我们将wrapper函数与内部func函数的参数设置*wargs,**kwargs就可以接收所有传进来的参数

#第二个问题，func接收参数

# 使用*wargs,**kwargs怎么接收参数
# 就使用*wargs,**kwargs怎么传递参数
# 我们可以把*wargs,**kwargs看成一个整体，接收所有的参数

def test2(name,age,gender): #test2(*(‘alex‘,18,‘male‘),**{})
    print(name)
    print(age)
    print(gender)
    
def test1(*args,**kwargs):
    test2(*args,**kwargs) #args=(‘alex‘,18,‘male‘)  kwargs={}
test1(‘alex‘,18,‘male‘)


def test3(*args,**kwargs):
    print(args)
    print(kwargs)
#
test3(1,2,3,4,name="linlin")
test3(*(1,2,3,4),**{‘name‘:‘linlin‘})

import time
def timmer(func):#func=test
    def wrapper():
        start_time = time.time()
        func()  # 就是在运行test()
        stop_time = time.time()
        print("函数运行时间的是%s" % (stop_time - start_time))
    return wrapper


def test():
    time.sleep(3)
    print(‘test函数运行完毕‘)
test=timmer(test)#返回的是wrapper的地址
test()#执行的是wrapper()