当我不想复制父类中的每个方法时，如何为 Python 子类中的每个方法添加延迟

Question

如果这个问题已经在某处得到回答，我深表歉意，但如果有，我无法找到答案。

我想创建一个父类的子类，在每次调用相应的父类方法之前会有一个延迟（例如time.sleep()）。我想这样做，我不需要在子类中复制每个父类方法。事实上，我希望有一个几乎可以与任何父类一起使用的通用方法——这样我什至不需要知道所有的父类方法。

实例化子类时会指定延迟。

例如：

class Parent():
    ....
    def method1(self):
        ....
    def method2(self):
        ....


class Child(Parent):
    def __init__(self, delay)
        self.delay = delay
        ....

child = Child(1)

调用child.method1() 会导致在调用Parent.method1() 之前延迟1 秒。

Answer 1

真的，你这里的设计涉及到一个策略对象。

您最好的方法是修复父类以包含对“延迟对象”的调用。默认延迟对象什么都不做。

这违反了“让我什至不需要知道所有父类的方法”所希望的功能集。

方法查找没有一个方便的__getmethod__ 对应于__getattribute__；这种差距使得很难利用 Python 的内部结构进行方法调用。

class Parent( object ):
    delay= ZeroDelay()
    def method1(self):
        self.delay()
        ....
    def method2(self):
        self.delay()
        ...

class ZeroDelay( object ):
    def __call__( self ):
        pass

class ShortDelay( ZeroDelay ):
    def __init__( self, duration=1.0 )
        self.duration= duration
    def __call__( self ):
        time.sleep( self.duration )

class Child( Parent ):
    delay= ShortDelay( 1 )

---

编辑：当然，你也可以装饰每个方法。

def delayed( delayer ):
    def wrap( a_method ):
        def do_delay( *args, **kw ):
            delayer()
            return a_method( *args, **kw )
        return do_delay
    return wrap


class Parent( object ):
    delay= ZeroDelay()
    @delayed( self.delay )
    def method1(self):
        self.delay()
        ....
    @delayed( self.delay )
    def method2(self):
        self.delay()
        ...

Answer 2

你可以使用__getattribute__的方法实现你想要的

class Child(Parent):
    def __init__(self, delay):
        self.delay = delay
    def __getattribute__(self, name):
        attr = object.__getattribute__(self, name)
        if hasattr(attr, '__call__'):
            def proxFct(*args, **kwargs):
                time.sleep(object.__getattribute__(self, "delay"))
                return attr(*args, **kwargs)
            return proxFct
        else:
            return attr

更新：根据delnan的评论更新

更新2：根据delnan的第二条评论更新

Answer 3

我认为之前给出的答案并没有真正解决您延迟父类中的所有方法的具体需求，并且不一定必须去装饰它们。您说您不想为了延迟它们而必须在子类中复制父类方法。这个答案使用来自 S.Lott 的相同延迟包装器，但也使用元类 (http://www.voidspace.org.uk/python/articles/metaclasses.shtml)

#!/usr/bin/env python

from types import FunctionType
import time


def MetaClassFactory(function):
    class MetaClass(type):
        def __new__(meta, classname, bases, classDict):
            newClassDict = {}
            for attributeName, attribute in classDict.items():
                if type(attribute) == FunctionType:
                    attribute = function(attribute)

                newClassDict[attributeName] = attribute
            return type.__new__(meta, classname, bases, newClassDict)
    return MetaClass


def delayed(func):
    def wrapped(*args, **kwargs):
        time.sleep(2)
        func(*args, **kwargs)
    return wrapped

Delayed = MetaClassFactory(delayed)

class MyClass(object):
    __metaclass__ = Delayed 

    def a(self):
        print 'foo'

    def b(self):
        print 'bar'

MetaClassFactory 将每个函数包装在延迟装饰器中。如果您想确保像 init 函数这样的某些内置函数没有延迟，您可以在 MetaClassFactory 中检查该名称并忽略它。

Answer 4

S.Lott 解决方案是一个很好的解决方案。如果您需要更多粒度（即仅延迟某些方法，而不是所有方法），您可以使用装饰器：

from time import sleep

def delayed(func):
    '''This is the decorator'''
    def wrapped(*args, **kwargs):
        sleep(2)
        func(*args, **kwargs)
    return wrapped

class Example(object):

    @delayed
    def method(self, str):
        print str

e = Example()
print "Brace! I'm delaying!"
e.method("I'm done!")

想法是在要删除的那些方法的定义之前添加@delayed。

---

编辑：更精细：设置任意延迟：

from time import sleep

def set_delay(seconds):
    def delayed(func):
        '''This is the decorator'''
        def wrapped(*args, **kwargs):
            sleep(seconds)
            func(*args, **kwargs)
        return wrapped
    return delayed

class Example(object):

    @set_delay(1)
    def method(self, str):
        print str

    @set_delay(2)
    def method_2(self, str):
        print str

e = Example()
print "Brace! I'm delaying!"
e.method("I'm done!")
e.method_2("I'm also done!")