python中的装饰器

什么是装饰器

假设有函数A，B，C，已经全部编写完成，这时你发现A, B, C都需要同一个功能，这时该怎么办？ 

答： 装饰器

装饰器本质是高阶函数，函数嵌套及闭包的结合体

高阶函数 

1. 函数接收的参数是一个函数名
2. 函数的返回值是一个函数
3. 以上两种满足一种即为高阶函数

高阶函数的例子

import time

# 高阶函数第一种情况 函数接受的方式是以个函数名

def timer(func):
    print("高阶函数第一种情况 函数接受的方式是以个函数名")
    starttime = time.time()
    res = func()
    stoptime = time.time()
    print("函数运行时间为%f"% (stoptime-starttime))
    return res


# 高阶函数第二种情况 函数的返回值是一个函数名

def timer2(func):
    print("高阶函数第二种情况，返回值是一个函数名")
    starttime = time.time()
    res = func()
    stoptime = time.time()
    print("函数运行时间为%f"% (stoptime-starttime))
    return func


def a():
    res = 0
    for i in range(1,20):
        time.sleep(0.1)
        res += i
    return res


res = timer(a) # timer函数的参数是一个函数名字
print(res) # 返回值是 a函数的执行结果

a = timer2(a)  # timer2的返回值是一个函数名
print(a()) # 执行这个函数

函数嵌套和闭包

函数嵌套指的是在函数中定义函数

闭包指的是函数和变量的作用域

如下面的例子，在a函数中定义了 b 函数，b函数中有定义了c函数，这些函数中有相同的变量name

执行a("Lee")时，b，c函数将会顺序执行

def a(name):  
    print("this is 1st level a %s"%name)  # 首先执行
    def b():
        print("this is 2nd level is b, my uplevel is a %s" %name)  # 因为b函数中没有定义 name变量，所以会从他的上一级函数中查找 name变量，变量值为 Lee
        def c():
            name = "Marlon" 
            print("this is 3rd level is c, my up one level is b %s" %name)  # 在c函数中定义了变量 name， 所以c函数输出的 name值为 Marlon
        c()
    b()
a("Lee")

装饰器的基本结构

def derator(func):  # 接收的参数为一个函数名
    def wrapper(*args,**kwargs):  # 接收函数所需要的参数 
        # 输入你所需要的功能   
        res = func(*args,**kwargs)  #  运行所接受的函数
        return res # return 传入函数的返回值
    return wrapper  # 返回值是一个函数名 

装饰器的例子

#!/usr/bin/env python 
#coding:utf-8
def SeparatorLine():
    print "############################"

#装饰器带参数函数带参数    
def DecratorArgFuncArg(f1,f2):
    def inner(func):
        def wrapper(arg):
            print "装饰器带参数函数带参数"
            f1()       
            result =  func(arg)
            f2()
            return result   
        return wrapper
    return inner

#装饰器带参数函数不带参数
def DecratorArgFuncNoArg(f1,f2):
    def inner(func):
        def wrapper():
            print "装饰器带参数函数不带参数"
            f1()       
            result=func()
            f2()
            return result
        return wrapper
    return inner

#函数没有参数的装饰器
def FuncNoArgDecrator(func):
    def wrapper():
        print "函数没有参数的装饰器"       
        func()
    return wrapper

#函数有参数的装饰器
def FuncArgDecrator(func):
    def wrapper(arg):
        print "函数有参数的装饰器"       
        func(arg)
    return wrapper

#函数有返回值的装饰器
def FuncReturnDecrator(func):
    def wrapper():
        print "函数有返回值的装饰器"       
        result=func()
        return result
    return wrapper

#这两个函数用
def login():
    print '开始登录'
   
def logout():
    print '退出登录'

@FuncArgDecrator # @ 被称为语法糖，例如加了这个语法糖的过程实际就是 ，就是将 Lee = FuncArgDecrator(Lee)
def Lee(arg):
    print 'I am %s' %arg

@FuncNoArgDecrator 
def Marlon():
    print 'i am Marlon'

@DecratorArgFuncNoArg(login,logout) 
def Allen():
    print 'i am Allen'  

@DecratorArgFuncArg(login,logout) # 相当于
def Aswill(name):
    print 'I am %s' %name  

@FuncReturnDecrator 
def Frank():
    return 'I am frank'

if __name__=='__main__':
    SeparatorLine()
    Lee('Lee')
    SeparatorLine()
    Marlon()
    SeparatorLine()
    Allen()
    SeparatorLine()
    Aswill('Aswill')
    SeparatorLine()
    result = Frank()
    print result