#_*_coding:utf-8_*_
def bibao(number):
    print ‘bibao function start‘
    def bibao_in(number2):
    #需要用到外函数的变量number
    return number + number2    
    #返回的是内函数的引用
    return bibao_in

#调用函数bibao(100)后，return回bibao_in函数的引用，test1就指向bibao_in
test1 = bibao(100)

#test1()调用的是bibao_in函数
print test1(200)

#又创建了一个指向bibao_in的对象test2
test2 = bibao(500)
print test2(200)

#_*_coding:utf-8_*_
def test(fn):
    #形参是一个函数
    def test_passwd():
        print ‘testing password‘
        if True:
        #调用函数fn
            fn()
    return test_passwd

def test3():
    print ‘a function‘

#1.将test3指向的函数地址作为形参，传入test中（执行后fn指向test3）; 
#2.test()函数返回结果是内函数test_passwd指向的函数体地址
#3.赋值语句，test3被重新定义，现在它指向test_passwd
test3 = test(test3)
#调用test3，也就调用了test_passwd，因它已与test_passwd指向同一函数体
test3()

#_*_coding:utf-8_*_

def test(fn):
    #形参是一个函数
    def test_passwd():
    	print ‘进行身份验证...‘
    	if True:
	    #调用函数fn
    	    fn()
    return test_passwd
‘‘‘使用语法糖进行装饰，作用就是更改test3指向的函数体，这可以帮助我们在不改变函数内部结构的情况下，增加它的功能（也就是对其装饰，比如对其增加一个验证功能，增加收集日志的功能）。@test与test3 = test(test3)等价‘‘‘
@test
def test3():
    print ‘start test3‘
#调用test3，也就调用了test_passwd，因它已与test_passwd指向同一函数体
test3()

结果：
进行身份验证...
start test3

def func(fn):
    print ‘开始装饰‘
    #使用可变参数类型，方便对多个不同参数的函数进行装饰
    def func_in(*args,**kwargs):
        print ‘校验中‘
        #fn调用了原来的test，所以一定也要有参数
        fn(*args,**kwargs)
    return func_in

#对有参数的函数进行装饰
@func   
def test(a,b,c):
    print ‘a=%d,b=%d,c=%d‘ % (a,b,c)

@func
def test2(a,b,c,d):
    print ‘a=%d,b=%d,c=%d,d=%d‘ % (a,b,c,d)

#如果不带参数，装饰器也可以对其进行装饰
@func
def test3():
    print ‘i have nothing‘

#调用时带参数，所以test指向的func_in函数也必须有参数
test(1,2,3)
test2(1,2,3,4)
test3()

结果：

#注意程序执行到@func语法糖时就进行装饰,不是函数被调用的时候被装饰的
开始装饰
开始装饰
开始装饰
校验中
a=1,b=2,c=3
校验中
a=1,b=2,c=3,d=4
校验中
i have nothing

例子五：
#_*_coding:utf-8_*_
def func(fn):
    print ‘开始装饰‘
    #使用可变长参数类型，方便对多个不同参数的函数进行装饰
    def func_in(*args,**kwargs):
        print ‘校验中‘
        #fn调用了原来的test，这里用rtn接收函数的返回值，再return rtn，这样就能保证返回原来函数的返回值
        rtn = fn(*args,**kwargs)
        return rtn
    return func_in

#对有参数的函数进行装饰
@func   
def test(a,b,c):
    print ‘a=%d,b=%d,c=%d‘ % (a,b,c)

#对有返回值的函数进行装饰
@func
def test3():
    return ‘i have nothing‘

#调用时带参数，所以test指向的func_in函数也必须有参数
test(1,2,3)

print test3()

结果：

开始装饰
开始装饰
校验中
a=1,b=2,c=3
校验中
i have nothing

def makeBold(fn):    # 1
    print ‘start Bold decorate‘
    def Bold(*args,**kwargs):
        print ‘make words Bold‘
        rtn = ‘<b>‘+ fn(*args,**kwargs) + ‘</b>‘
        return rtn
    return Bold

def makeItalian(fn):    # 2
    print ‘start Italian decorate‘
    def Italian(*args,**kwargs):
        print ‘make words italian‘
        rtn = ‘<i>‘ + fn(*args,**kwargs) + ‘</i>‘
        return rtn
    return Italian

@makeBold    # 3
@makeItalian    # 4
def words():    # 5
    return ‘hello Paris‘

print words()    # 6

结果：总结来说，python是从内到外进行装饰

start Italian decorate
start Bold decorate
make words Bold
make words italian
<b><i>hello Paris</i></b>

@deco2
@deco1
def func(arg1, arg2, ...): pass

#这和创建一个组合函数是等价的。
def func(arg1, arg2, ...): pass
func = deco2(deco1(func))

#函数组合用数学来定义就像这样: (g · f)(x) = g(f(x))。对于在python中的一致性：
@g
@f
def foo(): pass

#与 foo=g(f(foo))相同

#接收一个参数a
def with_arg(a):
    def bibao(fn):
    print ‘start decorate‘
    #被装饰的函数带参数
        def bibao_in(*arg,**kwarg):
            print ‘i am ‘+a
        #被装饰的参数带返回值
            rtn = fn(*arg,**kwarg)
            return rtn
    #返回bibao_in指向的函数体
        return bibao_in
    #返回bibao指向的函数体
    return bibao

#装饰器带参数时，先将这个参数传入with_arg()函数中，其返回函数bibao，再使用bibao对test1进行装饰
@with_arg(‘first‘)
def test1(a,b):
    print ‘i am test1‘
    return ‘sum is %d‘%(a+b)

@with_arg(‘second‘)
def test2():
    print ‘i am test2‘

print test1(1,2)
test2()

结果：

start decorate
start decorate
i am first
i am test1
sum is 3
i am second
i am test2