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