我跟别人说我精通python,别人问我wrapper是啥,我说不知道,尼玛,原来wrapper就是装饰器,熟的不得了啊,英语真是我的克星啊。

 

闭包 closure

在认识装饰器之前先认识下闭包

闭包,顾名思义就是把什么东西封闭在保内,什么东西呢?变量和函数。

在一个函数里装了另一个函数,里面那个函数称为内部函数,外面那个函数称为外部函数,

在内部函数里,对在外部作用域(非全局作用域)里的变量进行引用,这个内部函数就称为闭包

定义在外部函数内但被内部函数引用或调用的变量称为自由变量,所以闭包又被称为引用了自由变量的函数

 

内部函数和自由变量同时存在构建一个闭包实体,闭包的作用就是使闭包实体可以脱离创建它的环境运行,就是变量和函数脱离了创建它的环境依然存在,而且可执行,这点跟面向对象有些类似。

 

闭包的语法是一个函数A内创建了一个函数B,并且函数A返回了函数B,函数B就是闭包,函数A内的变量叫自由变量,包括A的参数

 

示例代码

def counter(start_at=0):
    print('act')
    count=[start_at]        # 自由变量
    def incr():             # 内部函数
        count[0]+=1
        return count[0]
    return incr             # 返回一个函数对象

count=counter(5)            # act
print 111                   # 111
print count()   # 6         # count 和 incr 脱离了创建它的环境,依然可以运行
print count()   # 7

count2=counter(100)         # act
print 222                   # 222
print count2()  # 101
print count()   # 8

闭包的作用

1. 闭包实际上是对数据或者数据操作的封装

2. 闭包可以实现一些通用的功能,它是装饰器的基础。

 

装饰器

装饰器本质上是个函数,一个用来包装函数的函数,返回被包装的函数对象。

被包装的函数需要作为装饰器函数的参数。

 

装饰器以语法糖@开头,形式如下

@decorator(dec_opt_args)
def func2Bdecorated(func_opt_args):

并且可以有多个装饰器

@deco2
@deco1
def func():
    pass

等价于 func=deco2(deco1(func))

 

普通方式实现类似装饰器的功能,以帮助理解

def deco(func):
    print("before myfunc() called.")
    func()
    print("  after myfunc() called.")
    return func

def myfunc():
    print(" myfunc() called.")

myfunc = deco(myfunc)
# before myfunc() called.
# myfunc() called.
# after myfunc() called.

myfunc()        #  myfunc() called.
myfunc()        #  myfunc() called.

 

使用语法糖@装饰函数,注意这并不是装饰器

def deco(func):
    print("before myfunc() called.")
    func()
    print("after myfunc() called.")
    return func

@deco
def myfunc():
    print("myfunc() called.")

myfunc()
# before myfunc() called.
# myfunc() called.
# after myfunc() called.
# myfunc() called.
print("*"*5)
myfunc()    #  myfunc() called.

可以看到第一次执行时@起了作用,第二次执行时@没起作用。为什么呢,往下看

 

真正的装饰器来了

无参装饰器

def deco(func):
    print(33)
    def _deco():
        print("before myfunc() called.")
        func()
        print("  after myfunc() called.")
    return _deco

@deco
def myfunc():
    print(" myfunc() called.")
    return 'ok'

myfunc()
# 33
# before myfunc() called.
# myfunc() called.
# after myfunc() called.
myfunc()
# before myfunc() called.
# myfunc() called.
# after myfunc() called.

可以看到每次执行@都起了作用,但是33只被打印了一次,又是为什么呢?

明明是执行了两次一模一样的操作,结果却不同,看来有必要深入理解一下装饰器了。

 

深入理解装饰器

之前讲到闭包类似于面向对象,而装饰器基于闭包,也应该类似于面向对象咯,或许吧,类似嘛,我又没说是,所以应该没错,

为什么扯这么多,因为我要用class来解释上面的问题。

 

对上面的无参装饰器分析一

## 上述过程类似这样
def myfunc():
    print(" myfunc() called.")
    return 'ok'

bb = deco(myfunc)       # 3
bb()
# before myfunc() called.
#  myfunc() called.
#   after myfunc() called.
bb()
# before myfunc() called.
#  myfunc() called.
#   after myfunc() called.

把装饰器转成普通函数,就明了了:

装饰器内的操作在创建装饰器实例时已经运行,这可以理解为class的实例化,如果在实例化时有print操作,在实例调用时不会再有

 

对上面的无参装饰器分析二

def deco(func):
    a = 3
    def _deco():
        print("before myfunc() called.")
        func()
        print(a)
        print("  after myfunc() called.")
    return _deco

@deco
def myfunc():
    print(" myfunc() called.")
    return 'ok'

myfunc()
# before myfunc() called.
#  myfunc() called.
# 3
#   after myfunc() called.
myfunc()
# before myfunc() called.
#  myfunc() called.
# 3
#   after myfunc() called.

装饰器传递的是自由变量和闭包,可以理解为class的实例属性和方法,在实例调用时,属性一直存在。

myfunc()第一次运行时相当于初始化了装饰器,后面只是调用实例,虽然它没有生成实例对象,在这点上不同于class。

 

总结

装饰器函数真的类似于面向对象

装饰器在第一次运行时相当于实例化class,实例化时可以有操作和属性,操作不被传递,属性被传递

装饰器不需要创建实例对象,运行即相当于实例化class

装饰器传递的是自由变量和属性,装饰器函数内的操作不被传递

 

装饰器的各种语法

有参装饰器

def deco(func):
    def _deco(a, b):
        print("before myfunc() called.")
        ret = func(a, b)
        print("  after myfunc() called. result: %s" % ret)
        return ret
    return _deco

@deco
def myfunc(a, b):
    print(" myfunc(%s,%s) called." % (a, b))
    return a + b

myfunc(1, 2)
# before myfunc() called.
#  myfunc(1,2) called.
#   after myfunc() called. result: 3
myfunc(3, 4)
# before myfunc() called.
#  myfunc(3,4) called.
#   after myfunc() called. result: 7

 

装饰器带参数

外面加一层

def deco(arg):
    def _deco(func):
        def __deco():
            print("before %s called [%s]." % (func.__name__, arg))
            func()
            print("  after %s called [%s]." % (func.__name__, arg))
        return __deco
    return _deco
 
@deco("mymodule")
def myfunc():
    print(" myfunc() called.")
 
@deco("module2")
def myfunc2():
    print(" myfunc2() called.")
 
myfunc()
myfunc2()

 

装饰器带类参数

装饰器的参数是个类,也可以是实例,或者其他

class locker:
    def __init__(self):
        print("locker.__init__() should be not called.")
         
    @staticmethod
    def acquire():
        print("locker.acquire() called.(这是静态方法)")
         
    @staticmethod
    def release():
        print("  locker.release() called.(不需要对象实例)")
 
def deco(cls):
    '''cls 必须实现acquire和release静态方法'''
    def _deco(func):
        def __deco():
            print("before %s called [%s]." % (func.__name__, cls))
            cls.acquire()
            try:
                return func()
            finally:
                cls.release()
        return __deco
    return _deco
 
@deco(locker)
def myfunc():
    print(" myfunc() called.")
 
myfunc()
myfunc()

 

被装饰的函数属性发生了变化

def deco(func):
    def myfunc(x):
        return func(x)
    return myfunc

@deco
def test1(x):
    return x+1

print(test1(4))         # 5
print(test1.__name__)   # myfunc    名字并非真实名字

名字并非真正函数的名字,而是装饰器函数里被装饰的函数的名字

 

保留被装饰的函数的属性

import time
import functools

def timeit(func):
    @functools.wraps(func)   # 此句就是用来保留被装饰的函数的属性的 ,其余跟普通装饰器一样
    def wrapper():
        start = time.clock()
        func()
        end =time.clock()
        print 'used:', end - start
    return wrapper

@timeit
def foo():
    print 'in foo()'

foo()       # used: 5.13182184074e-06
print foo.__name__   # foo

name属性被保留

 

 

参考资料:

http://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html