装饰器

闭包的一个例子：

def outer():
    x=10
    def inner():
        print(x)
    return inner       #inner被返回给了outer()
outer()()              #调用inner()
f=outer()              #f也指向inner()函数
f()                    #调用inner（）函数
#inner()    #inner是局部变量，全局无法调用

装饰器的一个例子：原来有一个函数foo()，现在我们想在执行该函数的同时计算执行时间

import time
def foo():
    print('hello 1')
    time.sleep(2)

下面的函数就是一个装饰器：

def show_time(f):
    def inner():    #inner函数实现计算时间
        start = time.time()     #时间戳
        f()
        end=time.time()
        print('spend %s' %(end-start))
    return inner

调用装饰器的方法：在foo函数前面@装饰器函数，实现它与装饰器的连接

@show_time    #这一句等价于foo=show_time(foo)，即让foo指向inner
def foo():
    print('hello 1')
    time.sleep(2)

foo()  #该语句等价于'show_time(foo)()':先执行show_time(其功能是show_time(foo)=inner)，再执行inner
       #foo函数将会在装饰器中被调用

被装饰函数带参数的例子
1.实现两个数相加

import time
def show_time(f):
    def inner(x,y):    #add指向inner，现在add有两个实参要传，所以要给inner加两个形参来接收实参
        start = time.time()
        f(x,y)
        end=time.time()
        print('spend %s' %(end-start))
    return inner

@show_time
def add(a,b):
    print(a+b)
    time.sleep(2)

add(1,2)

2.实现多个数相加

import time
def show_time(f):
    def inner(*x):    #add指向inner，现在add有两个实参要传，所以要给inner加两个形参来接收实参
        start = time.time()
        f(*x)
        end=time.time()
        print('spend %s' %(end-start))
    return inner

@show_time
def add(*a):
    sum=0
    for i in a:
        sum+=i
    print(sum)
    time.sleep(2)

add(1,2,3,4)

装饰器加参数：

import time
def logger(flag):        #在装饰器里定义一个新函数，用来接收参数
    def show_time(f):
        def inner(*x):
            start = time.time()
            f(*x)
            end=time.time()
            print('spend %s' %(end-start))
            if flag==5:
                print('记录日志')
        return inner
    return show_time

@logger(5)  #@外层函数，则执行该函数并返回内层函数地址，紧接着执行内层函数
def add(*a):
    sum=0
    for i in a:
        sum+=i
    print(sum)
    time.sleep(2)

add(1,2,3,4)  #@谁，执行谁