python 学习笔记7(装饰器)

闭包(closure)是函数式编程的重要的语法结构。

  定义:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure).

def outer():                               
    x = 1                                    
    def inner():                                       
        print(x)                                     
    return inner                               
f = outer()                                
f()                  

 

inner就是内部函数,inner里引用了外部作用域的变量x(x在外部作用域outer里面,不是全局作用域),则这个内部函数inner就是一个闭包。

闭包=函数块+定义函数时的环境,inner就是函数块,x就是环境。

装饰器

  装饰器本质上是一个函数,该函数用来处理其他函数,它可以让其他函数在不需要修改代码的前提下增加额外的功能,装饰器的返回值也是一个函数对象。

  它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等应用场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能

简单的装饰器函数:

@符号是装饰器的语法糖,在定义函数的时候使用,避免再一次赋值操作

import time
def shoe_time(f):
    def inner():
        start = time.time()
        f()
        end = time.time()
        print(end-start)
    return inner
@shoe_time   #foo = shoe_time(foo)
def foo():
    #start = time.time()
    print("foo......")
    time.sleep(2)
    #end = time.time()
    #print(end-start)               #2.0001144409179688
#foo()
@shoe_time     #bar = shoe_time(bar)
def bar():
    # start = time.time()
    print("bar......")
    time.sleep(3)
    #end = time.time()
    #print(end-start)                #3.001171588897705
#bar()
#shoe_time(foo)              #2.0001142024993896
#shoe_time(bar)                #3.001171588897705
foo()                      #foo......                           # 2.0001144409179688
bar()                       # bar......
                          # 3.00017142295837

 

带参数的被装饰函数

#功能函数加参数
import time
def shoe_time(f):
     def inner(x,y):
         start = time.time()
         f(x,y)
         end = time.time()
         print(end-start)
     return inner
@shoe_time
def add(a,b):
    print(a+b)
    time.sleep(3)
#@shoe_time
# def foo():
#     print("foo......")
#     time.sleep(2)
# @shoe_time
# def bar():
#      print("bar......")
#      time.sleep(3)
#
add(1,3)       #4
               #3.000171661376953


#不定长参数
import time
def shoe_time(f):
     def inner(*x,**y):
         start = time.time()
         f(*x,**y)
         end = time.time()
         print(end-start)
     return inner
@shoe_time
def add(*a,**b):
    sum = 0
    for i in a:
        sum += i
    print(sum)
    time.sleep(3)
#@shoe_time
# def foo():
#     print("foo......")
#     time.sleep(2)
# @shoe_time
# def bar():
#      print("bar......")
#      time.sleep(3)
#
add(1,3,4,6,78)              #92
                             #3.000171661376953

带参数的装饰器

  装饰器还有更大的灵活性,例如带参数的装饰器:在上面的装饰器调用中,比如@shoe_time,该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时,提供其它参数,比如@decorator(a)。这样,就为装饰器的编写和使用提供了更大的灵活性。

#带参数的装饰器

import time
def logger(flag=""):
    def shoe_time(f):
         def inner(*x,**y):
             start = time.time()
             f(*x,**y)
             end = time.time()
             print(end-start)
             if flag == "true":
                 with open("日志记录", "a",encoding="utf8") as g:
                     g.write("值为: %s 时间为: %s\n"%(f(*x),(end-start)))
         return inner
    return shoe_time
@logger("true")     #@show_time
def add(*a,**b):
    Sum = 0
    for i in a:
        Sum += i
    print(Sum)
    time.sleep(3)
    return Sum
@logger("abc")
def foo():
    print("foo......")
    time.sleep(2)
# @shoe_time
# def bar():
#     print("bar......")
#     time.sleep(3)

add(1,3,4,6,78)      #92
                    #3.000171661376953
foo()

  @logger("true") 做了两件事:

    (1)@ogger("true"):得到闭包函数show_time,里面保存环境变量flag

    (2)@time   :add=show_time(add)

上面的logger是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装,并返回一个装饰器(一个含有参数的闭包函数)。当我 们使用@logger("true")调用的时候,Python能够发现这一层的封装,并把参数传递到装饰器的环境中。

 

 

 

 

 

 

 

 

 

 

 

 

 
posted on 2016-09-08 01:04  别拿曾经看以后  阅读(194)  评论(0编辑  收藏  举报