Python 装饰器与面向切面编程

最新推荐文章于 2024-05-16 21:44:08 发布

wh62592855

最新推荐文章于 2024-05-16 21:44:08 发布

阅读量1.3k

点赞数

分类专栏： Python 文章标签： python decorator wrapper lambda import 编程

Python 专栏收录该内容

84 篇文章 1 订阅

订阅专栏

什么是AOP

##############

今天来讨论一下装饰器。装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

1. 装饰器入门

1.1. 需求是怎么来的？

装饰器的定义很是抽象，我们来看一个小例子。

 
   1def  foo():
 
   2    print'in foo()'
 
   3 
 
   4foo()

这是一个很无聊的函数没错。但是突然有一个更无聊的人，我们称呼他为B君，说我想看看执行这个函数用了多长时间，好吧，那么我们可以这样做：

 
   1import  time
 
   2def  foo():
 
   3    start=time.clock()
 
   4    print'in foo()'
 
   5    end=time.clock()
 
   6    print'used:', end- start
 
   7 
 
   8foo()

很好，功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了，他对另一个叫foo2的函数产生了更浓厚的兴趣。

怎么办呢？如果把以上新增加的代码复制到foo2里，这就犯了大忌了~复制什么的难道不是最讨厌了么！而且，如果B君继续看了其他的函数呢？

1.2. 以不变应万变，是变也

还记得吗，函数在Python中是一等公民，那么我们可以考虑重新定义一个函数timeit，将foo的引用传递给他，然后在timeit中调用foo并进行计时，这样，我们就达到了不改动foo定义的目的，而且，不论B君看了多少个函数，我们都不用去修改函数定义了！

 
   01import  time
 
   02 
 
   03def  foo():
 
   04    print'in foo()'
 
   05 
 
   06def  timeit(func):
 
   07    start=time.clock()
 
   08    func()
 
   09    end=time.clock()
 
   10    print'used:', end- start
 
   11 
 
   12timeit(foo)

看起来逻辑上并没有问题，一切都很美好并且运作正常！……等等，我们似乎修改了调用部分的代码。原本我们是这样调用的：foo()，修改以后变成了：timeit(foo)。这样的话，如果foo在N处都被调用了，你就不得不去修改这N处的代码。或者更极端的，考虑其中某处调用的代码无法修改这个情况，比如：这个函数是你交给别人使用的。

1.3. 最大限度地少改动！

既然如此，我们就来想想办法不修改调用的代码；如果不修改调用代码，也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo，但是timeit似乎带有一个参数……想办法把参数统一吧！如果timeit(foo)不是直接产生调用效果，而是返回一个与foo参数列表一致的函数的话……就很好办了，将timeit(foo)的返回值赋值给foo，然后，调用foo()的代码完全不用修改！

 
   01#-*- coding: UTF-8 -*-
 
   02import  time
 
   03 
 
   04def  foo():
 
   05    print'in foo()'
 
   06 
 
   07# 定义一个计时器，传入一个，并返回另一个附加了计时功能的方法
 
   08def  timeit(func):
 
   09     
 
   10    # 定义一个内嵌的包装函数，给传入的函数加上计时功能的包装
 
   11    defwrapper():
 
   12        start=time.clock()
 
   13        func()
 
   14        end=time.clock()
 
   15        print'used:', end- start
 
   16     
 
   17    # 将包装后的函数返回
 
   18    returnwrapper
 
   19 
 
   20foo =timeit(foo)
 
   21foo()

这样，一个简易的计时器就做好了！我们只需要在定义foo以后调用foo之前，加上foo = timeit(foo)，就可以达到计时的目的，这也就是装饰器的概念，看起来像是foo被timeit装饰了。在在这个例子中，函数进入和退出时需要计时，这被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言，像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里，能减少大量重复代码。面向切面编程还有相当多的术语，这里就不多做介绍，感兴趣的话可以去找找相关的资料。

这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了：）

2. Python的额外支持

2.1. 语法糖

上面这段代码看起来似乎已经不能再精简了，Python于是提供了一个语法糖来降低字符输入量。

 
   01import  time
 
   02 
 
   03def  timeit(func):
 
   04    defwrapper():
 
   05        start=time.clock()
 
   06        func()
 
   07        end=time.clock()
 
   08        print'used:', end- start
 
   09    returnwrapper
 
   10 
 
   11@timeit
 
   12def  foo():
 
   13    print'in foo()'
 
   14 
 
   15foo()

重点关注第11行的@timeit，在定义上加上这一行与另外写foo = timeit(foo)完全等价，千万不要以为@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感觉。

2.2. 内置的装饰器

内置的装饰器有三个，分别是staticmethod、classmethod和property，作用分别是把类中定义的实例方法变成静态方法、类方法和类属性。由于模块里可以定义函数，所以静态方法和类方法的用处并不是太多，除非你想要完全的面向对象编程。而属性也不是不可或缺的，Java没有属性也一样活得很滋润。从我个人的Python经验来看，我没有使用过property，使用staticmethod和classmethod的频率也非常低。

 
   01class  Rabbit(object):
 
   02     
 
   03    def__init__(self, name):
 
   04        self._name=name
 
   05     
 
   06    @staticmethod
 
   07    defnewRabbit(name):
 
   08        returnRabbit(name)
 
   09     
 
   10    @classmethod
 
   11    defnewRabbit2(cls):
 
   12        returnRabbit('')
 
   13     
 
   14    @property
 
   15    defname(self):
 
   16        returnself._name

这里定义的属性是一个只读属性，如果需要可写，则需要再定义一个setter：

 
   1@name.setter
 
   2def  name(self, name):
 
   3    self._name=name

2.3. functools模块

functools模块提供了两个装饰器。这个模块是Python 2.5后新增的，一般来说大家用的应该都高于这个版本。但我平时的工作环境是2.4 T-T

2.3.1. wraps(wrapped[, assigned][, updated]):
这是一个很有用的装饰器。看过前一篇反射的朋友应该知道，函数是有几个特殊属性比如函数名，在被装饰后，上例中的函数名foo会变成包装函数的名字wrapper，如果你希望使用反射，可能会导致意外的结果。这个装饰器可以解决这个问题，它能将装饰过的函数的特殊属性保留。

 
   01import  time
 
   02import  functools
 
   03 
 
   04def  timeit(func):
 
   05    @functools.wraps(func)
 
   06    defwrapper():
 
   07        start=time.clock()
 
   08        func()
 
   09        end=time.clock()
 
   10        print'used:', end- start
 
   11    returnwrapper
 
   12 
 
   13@timeit
 
   14def  foo():
 
   15    print'in foo()'
 
   16 
 
   17foo()
 
   18print  foo.__name__

首先注意第5行，如果注释这一行，foo.__name__将是'wrapper'。另外相信你也注意到了，这个装饰器竟然带有一个参数。实际上，他还有另外两个可选的参数，assigned中的属性名将使用赋值的方式替换，而updated中的属性名将使用update的方式合并，你可以通过查看functools的源代码获得它们的默认值。对于这个装饰器，相当于wrapper = functools.wraps(func)(wrapper)。

2.3.2. total_ordering(cls):
这个装饰器在特定的场合有一定用处，但是它是在Python 2.7后新增的。它的作用是为实现了至少__lt__、__le__、__gt__、__ge__其中一个的类加上其他的比较方法，这是一个类装饰器。如果觉得不好理解，不妨仔细看看这个装饰器的源代码：

 
   0153   def total_ordering(cls):
 
   0254       """Class decorator that fills in missing ordering methods"""
 
   0355       convert = {
 
   0456           '__lt__': [('__gt__',lambdaself, other: other <self),
 
   0557                      ('__le__',  lambda self, other:notother <self),
 
   0658                      ('__ge__',  lambda self, other:notself< other)],
 
   0759           '__le__': [('__ge__',lambdaself, other: other <=self),
 
   0860                      ('__lt__',  lambda self, other:notother <=self),
 
   0961                      ('__gt__',  lambda self, other:notself<=other)],
 
   1062           '__gt__': [('__lt__',lambdaself, other: other >self),
 
   1163                      ('__ge__',  lambda self, other:notother >self),
 
   1264                      ('__le__',  lambda self, other:notself> other)],
 
   1365           '__ge__': [('__le__',lambdaself, other: other >=self),
 
   1466                      ('__gt__',  lambda self, other:notother >=self),
 
   1567                      ('__lt__',  lambda self, other:notself>=other)]
 
   1668       }
 
   1769       roots =  set(dir(cls)) &set(convert)
 
   1870       if not roots:
 
   1971           raise ValueError('must define at least one ordering operation: < > <= >=')
 
   2072       root =  max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
 
   2173       for opname, opfunc inconvert[root]:
 
   2274           if opname notinroots:
 
   2375               opfunc.__name__ =  opname
 
   2476               opfunc.__doc__ =  getattr(int, opname).__doc__
 
   2577               setattr(cls, opname, opfunc)
 
   2678       return cls

本文转自http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html

######小例子###

def wrapper(f):
    def f_new(*args, **argkw):
        print "before %s"%f.func_name
        return f(*args, **argkw)
        print "after %s"%f.func_name
    return f_new
  
@wrapper
def f1(p1):
    print 'in func1'
    print p1
    
@wrapper
def f2(p1,p2):
    print 'in func2'
    print p1,p2
    
f1('xx')
f2('yy')

########又发现篇不错的文章######

在我以前介绍 Python 2.4 特性的Blog中已经介绍过了decorator了，不过，那时是照猫画虎，现在再仔细描述一下它的使用。

关于decorator的详细介绍在 Python 2.4中的What’s new中已经有介绍，大家可以看一下。

如何调用decorator

基本上调用decorator有两种形式

第一种：

@A
def f ():
…

这种形式是decorator不带参数的写法。最终 Python 会处理为：

f = A(f)

还可以扩展成：

@A
@B
@C
def f ():
…

最终 Python 会处理为：

f = A(B(C(f)))

注：文档上写的是@A @B @C的形式，但实际上是不行的，要写成多行。而且执行顺序是按函数调用顺序来的，先最下面的C，然后是B，然后是A。因此，如果decorator有顺序话，一定要注意：先要执行的放在最下面，最后执行的放在最上面。(应该不存在这种倒序的关系)

第二种：

@A(args)
def f ():
…

这种形式是decorator带参数的写法。那么 Python 会处理为：

def f(): …
_deco = A(args)
f = _deco(f)

可以看出， Python 会先执行A(args)得到一个decorator函数，然后再按与第一种一样的方式进行处理。

decorator函数的定义

每一个decorator都对应有相应的函数，它要对后面的函数进行处理，要么返回原来的函数对象，要么返回一个新的函数对象。请注意，decorator只用来处理函数和类方法。

第一种：

针对于第一种调用形式

def A(func):
    #处理func
    #如func.attr=’decorated’
    return func
@A
def f(args):pass

上面是对func处理后，仍返回原函数对象。这个decorator函数的参数为要处理的函数。如果要返回一个新的函数，可以为：

def A(func):
    def new_func(args):
        #做一些额外的工作
        return func(args) #调用原函数继续进行处理
    return new_func
@A
def f(args):pass

要注意 new_func的定义形式要与待处理的函数相同，因此还可以写得通用一些，如：

def A(func):
    def new_func(*args, **argkw):
        #做一些额外的工作
        return func(*args, **argkw) #调用原函数继续进行处理
    return new_func
@A
def f(args):pass

可以看出，在A中定义了新的函数，然后A返回这个新的函数。在新函数中，先处理一些事情，比如对参数进行检查，或做一些其它的工作，然后再调原始的函数进行处理。这种模式可以看成，在调用函数前，通过使用decorator技术，可以在调用函数之前进行了一些处理。如果你想在调用函数之后进行一些处理，或者再进一步，在调用函数之后，根据函数的返回值进行一些处理可以写成这样：

def A(func):
    def new_func(*args, **argkw):
        result = func(*args, **argkw) #调用原函数继续进行处理
        if result:
            #做一些额外的工作
            return new_result
        else:
            return result
    return new_func
@A
def f(args):pass

第二种：

针对第二种调用形式

在文档上说，如果你的decorator在调用时使用了参数，那么你的decorator函数只会使用这些参数进行调用，因此你需要返回一个新的decorator函数，这样就与第一种形式一致了。

def A(arg):
    def _A(func):
        def new_func(args):
            #做一些额外的工作
            return func(args)
        return new_func
    return _A
@A(arg)
def f(args):pass

可以看出A(arg)返回了一个新的 decorator _A。

decorator的应用场景

不过我也一直在想，到底decorator的魔力是什么？适合在哪些场合呢？是否我需要使用它呢？

decorator的魔力就是它可以对所修饰的函数进行加工。那么这种加工是在不改变原来函数代码的情况下进行的。有点象我知道那么一点点的AOP(面向方面编程)的想法。

它适合的场合我能想到的列举出下：

象文档中所说，最初是为了使调用staticmethod和classmethod这样的方法更方便
在某些函数执行前做一些工作，如web开发中，许多函数在调用前需要先检查一下用户是否已经登录，然后才能调用
在某此函数执行后做一些工作，如调用完毕后，根据返回状态写日志
做参数检查

可能还有许多，你可以自由发挥想象

那么我需要用它吗？

我想那要看你了。不过，我想在某些情况下，使用decorator可以增加程序的灵活性，减少耦合度。比如前面所说的用户登录检查。的确可以写一个通用的登录检查函数，然后在每个函数中进行调用。但这样会造成函数不够灵活，而且增加了与其它函数之间的结合程度。如果用户登录检查功能有所修改，比如返回值的判断发生了变化，有可能每个用到它的函数都要修改。而使用decorator不会造成这一问题。同时使用decorator的语法也使得代码简单，清晰(一但你熟悉它的语法的话)。当然你不使用它是可以的。不过，这种函数之间相互结合的方式，更符合搭积木的要求，它可以把函数功能进一步分解，使得功能足够简单和单一。然后再通过decorator的机制灵活的把相关的函数串成一个串，这么一想，还真是不错。比如下面：

@A
@B
def account(args):pass

假设这是一个记帐处理函数，account只管记帐。但一个真正的记帐还有一些判断和处理，比如：B检查帐户状态，A记日志。这样的效果其实是先检查B、通过在A中的处理可以先执行account，然后再进行记日志的处理。象搭积木一样很方便，改起来也容易。甚至可以把account也写成decorator，而下面执行的函数是一个空函数。然后再通过配置文件等方法，将decorator的组合保存起来，就基本实现功能的组装化。是不是非常理想。

Python 带给人的创造力真是无穷啊！

转自：http://blog.donews.com/limodou/archive/2004/12/19/207521.aspx

wh62592855

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Python 装饰器与面向切面编程

什么是AOP##############今天来讨论一下装饰器。装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。1. 装饰器入门1.1. 需求是怎么来的？
复制链接

扫一扫