Python装饰器（函数）

闭包

１．作用域L_E_G_B(局部、内嵌、全局...)：

x=10#全局

def f():
    a=5　＃嵌套作用域
    def inner():
        count = 7 #局部变量
        print a
        return 1

从内往外寻找 a 。

２．高阶函数

a.函数名可以作为参数输入

b.函数名可以作为返回值

３．闭包

def outer():
    x=10
    def inner(): #条件１　inner是内部函数
        print(x) #条件２　外部环境的一个变量

    return inner #结论：　内部函数inner就是一个闭包

outer()()#调用inner
#同上
f = outer()#获得inner
f()#调用执行inner

#不能直接调用inner,因为inner为局部变量，全局无法调用

执行结果

10
10

Process finished with exit code 0

第10行，获得inner变量，第11行执行inner函数，而执行inner函数时（在外部执行），其中x变量既不属于inner函数内部变量，也不属于全局变量，按理应该报错却没报错，这种现象称为闭包。

定义：如果在一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）。

在内部函数里（inner函数中），对在外部作用域的变量（x）进行引用（print）,那么内部函数（inner）就被认为是闭包。

装饰器

import time

def foo():
    print("foo.....")
    time.sleep(2)

def bar():
    print("bar.....")
    time.sleep(3)

def show_time(f): #函数名作参数
    start = time.time()
    f()
    end = time.time()
    print("spend %s" % (end - start))


show_time(bar)

函数名作参数，减少重复代码。

执行结果：

bar.....
spend 3.0022976398468018

Process finished with exit code 0

 但是以上方法改变了调用方式，加上所需时间功能后，不是直接用foo，而是用show_time，这样对所有使用foo函数的代码都需修改，违背了封闭开放原则。

import time

def foo():
    print("foo.....")
    time.sleep(2)

def bar():
    print("bar.....")
    time.sleep(3)

def show_time(f): #函数名作参数 ,装饰器
    def inner():
        start = time.time()
        f()
        end = time.time()
        print("spend %s" % (end - start))
    return inner

foo = show_time(foo)
foo()

show_time即为装饰器，inner函数为闭包，f函数名变量即为外部作用域变量。

执行结果：

foo.....
spend 2.00213360786438

Process finished with exit code 0

但是以上方法还需要自己赋值，不够简便、优雅。

优雅的写法：

import time

def show_time(f): #函数名作参数 ,装饰器
    def inner():
        start = time.time()
        f()
        end = time.time()
        print("spend %s" % (end - start))
    return inner

@show_time  #  foo = show_time(foo), 给foo函数添加一个计算所需时间的功能
def foo():
    print("foo.....")
    time.sleep(2)

#foo = show_time(foo)
foo()

11行，给foo函数添加一个计算所需时间的功能，@show_time,可理解为foo = show_time(foo)。

执行结果：

foo.....
spend 2.002133369445801

Process finished with exit code 0

 被装饰函数参数（功能函数加参数）：

import time

def show_time(f): #函数名作参数 ,装饰器
    def inner(x, y):
        start = time.time()
        f(x, y)
        end = time.time()
        print("spend %s" % (end - start))
    return inner

@show_time  #  add = show_time(add), 给add函数添加一个计算所需时间的功能
def add(a, b):
    print(a + b)
    time.sleep(1)

#foo = show_time(foo)
add(1, 2)

执行结果：

3
spend 1.0010321140289307

Process finished with exit code 0

不定长参数：

import time

def show_time(f): #函数名作参数 ,装饰器
    def inner(*x, **y):
        start = time.time()
        f(*x, **y)
        end = time.time()
        print("spend %s" % (end - start))
    return inner

@show_time
def add(*a, **b): #　a为元组
    sums = 0
    for i in a:
        sums += i
    print(sums)
    time.sleep(1)


add(1, 2, 5, 7, 9)#不定长参数

其中a为元组。

执行结果：

24
spend 1.0011086463928223

Process finished with exit code 0

装饰器参数：

import time

def logger(flag=''):#默认空

    def show_time(f):  # 函数名作参数 ,装饰器
        def inner(*x, **y):
            start = time.time()
            f(*x, **y)
            end = time.time()
            print("spend %s" % (end - start))
            if flag == 'true':
                print('日志记录')
        return inner
    return show_time

def show_time(f): #函数名作参数 ,装饰器
    def inner(*x, **y):
        start = time.time()
        f(*x, **y)
        end = time.time()
        print("spend %s" % (end - start))
    return inner

@logger('true') # 相当于＠show_time,不过有了一个flag变量，相当于闭包
def add(*a, **b): #　a为元组
    sums = 0
    for i in a:
        sums += i
    print(sums)
    time.sleep(1)

add(1, 2, 5, 7, 9)#不定长参数

@logger()
def bar():
    print("bar......")
    time.sleep(3)

bar()

装饰器加参数flag,决定是否输出日志，此时show_time为闭包。

执行结果：

24
spend 1.001152515411377
日志记录
bar......
spend 3.00311541557312