在Python中实现装饰器模式

Question

我想在Python中实现decorator pattern，我想知道是否有办法编写一个装饰器来实现它想要修改的功能，而无需为所有的函数只是被转发到装饰对象。像这样：

class foo(object): 
    def f1(self): 
     print "original f1" 
    def f2(self): 
     print "original f2" 

class foo_decorator(object): 
    def __init__(self, decoratee): 
     self._decoratee = decoratee 
    def f1(self): 
     print "decorated f1" 
     self._decoratee.f1() 
    def f2(self):    # I would like to leave that part out 
     self._decoratee.f2() 

我想有转发给decoratee.f2自动foo_decorator.f2电话。有没有办法编写一个将所有未实现函数调用转发到decoratee的泛型方法？

Answer 1

您可以使用__getattr__：

class foo(object): 
    def f1(self): 
     print "original f1" 
    def f2(self): 
     print "original f2" 

class foo_decorator(object): 
    def __init__(self, decoratee): 
     self._decoratee = decoratee 
    def f1(self): 
     print "decorated f1" 
     self._decoratee.f1() 
    def __getattr__(self, name): 
     return getattr(self._decoratee, name) 

u = foo() 
v = foo_decorator(u) 
v.f1() 
v.f2() 

Answer 2

这可以说是不是最好的做法，但是你能为实例添加的功能，像我那样，以帮助过渡从Django的ORM到SQLAlachemy我的代码，如下所示：

def _save(self): 
    session.add(self) 
    session.commit() 
setattr(Base,'save',_save) 

Answer 3

链接维基百科文章中的UML图是错误的，您的代码也是错误的。

如果您遵循“装饰器模式”，装饰器类将从基础装饰类派生。 （在UML图中，缺少WindowDecorator到Window的继承箭头）。

与

class foo_decorator(foo): 

你不需要未修饰的实现方法。

顺便说一句：在强类型语言中，还有一个原因，为什么装饰器必须从装饰类派生：否则你不能链装饰器。

Answer 4

作为菲利普答案的附录;如果你不仅需要装修，但保留对象的类型，Python允许您在运行时子类的实例：

class foo(object): 
    def f1(self): 
     print "original f1" 

    def f2(self): 
     print "original f2" 


class foo_decorator(object): 
    def __new__(cls, decoratee): 
     cls = type('decorated', 
        (foo_decorator, decoratee.__class__), 
        decoratee.__dict__) 
     return object.__new__(cls) 

    def f1(self): 
     print "decorated f1" 
     super(foo_decorator, self).f1() 


u = foo() 
v = foo_decorator(u) 
v.f1() 
v.f2() 
print 'isinstance(v, foo) ==', isinstance(v, foo) 

这是更多地参与不是严格一点需要为您的例子，在那里你知道正在提前装修的班级。

这威力足矣：

class foo_decorator(foo): 
    def __init__(self, decoratee): 
     self.__dict__.update(decoratee.__dict__) 

    def f1(self): 
     print "decorated f1" 
     super(foo_decorator, self).f1() 

Answer 5

为了补充@Alec托马斯答复。我修改了他的答案以遵循装饰器模式。这样你就不需要事先知道你正在装修的课程。

class Decorator(object): 
    def __new__(cls, decoratee): 
     cls = type('decorated', 
        (cls, decoratee.__class__), 
        decoratee.__dict__) 
     return object.__new__(cls) 

然后，你可以使用它作为：

class SpecificDecorator(Decorator): 
    def f1(self): 
     print "decorated f1" 
     super(foo_decorator, self).f1() 

class Decorated(object): 
    def f1(self): 
     print "original f1" 


d = SpecificDecorator(Decorated()) 
d.f1() 

Answer 6

在我的项目之一，我也需要做一个特别的事情，那就是即使是底层对象应实际执行的方法在装饰器中被重新实现。如果你知道它的目标是什么，它确实很容易做到。

用例是：

• 我有方法A和B.对象X
• 我创建一个装饰类Y来覆盖A.
• 如果我实例化Y（X）并调用A，它将按照预期使用装饰A.
• 如果B调用A，那么如果我实例化Y（X）并在装饰器上调用B，则B中的调用将转到原始对象上的旧A，这是不受欢迎的。我想让老B也叫新A。

有可能达到这样的这种行为：

import inspect 
import six  # for handling 2-3 compatibility 

class MyBaseDecorator(object): 
    def __init__(self, decorated): 
     self.decorated = decorated 

    def __getattr__(self, attr): 
     value = getattr(self.decorated, attr) 
     if inspect.ismethod(value): 
      function = six.get_method_function(value) 
      value = function.__get__(self, type(self)) 
     return value 

class SomeObject(object): 
    def a(self): 
     pass 

    def b(self): 
     pass 

class MyDecorator(MyBaseDecorator): 
    def a(self): 
     pass 

decorated = MyDecorator(SomeObject()) 

这可能不起作用开箱即用，因为我打字从GETATTR方法一切除了我的头顶。

代码查找装饰对象中的请求属性，如果它是一个方法（现在不适用于属性，但支持它们的更改不应太困难），则代码将实际函数超出了方法，并使用描述符接口调用，它将函数作为方法“重新绑定”，但在装饰器上。然后返回并最有可能执行。

这样做的效果是，如果b有史以来最原始的对象上调用a，那么当你有装饰物并没有任何方法调用从装饰来临，装饰可以确保访问的所有方法都绑定到而是使用装饰器而不是原始对象查找事物，因此装饰器中指定的方法优先。

P.S .:是的我知道它看起来很像继承，但这是在多个对象的组合意义上完成的。