类中的 Python 装饰器

Question

可以写这样的东西吗：

class Test(object):
    def _decorator(self, foo):
        foo()

    @self._decorator
    def bar(self):
        pass

这失败了：@self 中的 self 未知

我也尝试过：

@Test._decorator(self)

也失败了：测试未知

我想暂时更改一些实例变量在装饰器中，然后运行装饰方法，之前将它们改回来。

Answer 1

这样的东西可以满足您的需要吗？

class Test(object):
    def _decorator(foo):
        def magic( self ) :
            print "start magic"
            foo( self )
            print "end magic"
        return magic

    @_decorator
    def bar( self ) :
        print "normal call"

test = Test()

test.bar()

这避免了调用 self 来访问装饰器，并将其作为常规方法隐藏在类命名空间中。

>>> import stackoverflow
>>> test = stackoverflow.Test()
>>> test.bar()
start magic
normal call
end magic
>>>

编辑回答评论中的问题：

如何在另一个类中使用隐藏装饰器

class Test(object):
    def _decorator(foo):
        def magic( self ) :
            print "start magic"
            foo( self )
            print "end magic"
        return magic

    @_decorator
    def bar( self ) :
        print "normal call"

    _decorator = staticmethod( _decorator )

class TestB( Test ):
    @Test._decorator
    def bar( self ):
        print "override bar in"
        super( TestB, self ).bar()
        print "override bar out"

print "Normal:"
test = Test()
test.bar()
print

print "Inherited:"
b = TestB()
b.bar()
print

输出：

Normal:
start magic
normal call
end magic

Inherited:
start magic
override bar in
start magic
normal call
end magic
override bar out
end magic

Answer 2

你想做的事情是不可能的。以下面的代码看起来是否有效为例：

class Test(object):

    def _decorator(self, foo):
        foo()

    def bar(self):
        pass
    bar = self._decorator(bar)

当然，它是无效的，因为当时尚未定义

self

。

Test

也是如此，因为直到类本身被定义（正在定义过程中）它才会被定义。我向您展示此代码片段是因为 这就是您的装饰器片段转换成的内容。

因此，正如您所看到的，像这样访问装饰器中的实例实际上是不可能的，因为装饰器是在它们所附加的任何函数/方法的定义期间应用的，而不是在实例化期间应用。

如果您需要类级别访问权限，请尝试以下操作：

class Test(object):

    @classmethod
    def _decorator(cls, foo):
        foo()

    def bar(self):
        pass
Test.bar = Test._decorator(Test.bar)

Answer 3

import functools


class Example:

    def wrapper(func):
        @functools.wraps(func)
        def wrap(self, *args, **kwargs):
            print("inside wrap")
            return func(self, *args, **kwargs)
        return wrap

    @wrapper
    def method(self):
        print("METHOD")

    wrapper = staticmethod(wrapper)


e = Example()
e.method()

Answer 4

这是从同一个类中定义的

self

访问（并已使用）

decorator

的一种方法：

class Thing(object):
    def __init__(self, name):
        self.name = name

    def debug_name(function):
        def debug_wrapper(*args):
            self = args[0]
            print 'self.name = ' + self.name
            print 'running function {}()'.format(function.__name__)
            function(*args)
            print 'self.name = ' + self.name
        return debug_wrapper

    @debug_name
    def set_name(self, new_name):
        self.name = new_name

输出（在

Python 2.7.10

上测试）：

>>> a = Thing('A')
>>> a.name
'A'
>>> a.set_name('B')
self.name = A
running function set_name()
self.name = B
>>> a.name
'B'

上面的例子很傻，但是很有效。

Answer 5

这是对 Michael Speer 答案的扩展，以进一步实现：

一个实例方法装饰器，它接受参数并作用于带有参数和返回值的函数。

class Test(object):
    "Prints if x == y. Throws an error otherwise."
    def __init__(self, x):
        self.x = x

    def _outer_decorator(y):
        def _decorator(foo):
            def magic(self, *args, **kwargs) :
                print("start magic")
                if self.x == y:
                    return foo(self, *args, **kwargs)
                else:
                    raise ValueError("x ({}) != y ({})".format(self.x, y))
                print("end magic")
            return magic

        return _decorator

    @_outer_decorator(y=3)
    def bar(self, *args, **kwargs) :
        print("normal call")
        print("args: {}".format(args))
        print("kwargs: {}".format(kwargs))

        return 27

然后

In [2]:

    test = Test(3)
    test.bar(
        13,
        'Test',
        q=9,
        lollipop=[1,2,3]
    )
    
    start magic
    normal call
    args: (13, 'Test')
    kwargs: {'q': 9, 'lollipop': [1, 2, 3]}
Out[2]:
    27
In [3]:

    test = Test(4)
    test.bar(
        13,
        'Test',
        q=9,
        lollipop=[1,2,3]
    )
    
    start magic
    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-3-576146b3d37e> in <module>()
          4     'Test',
          5     q=9,
    ----> 6     lollipop=[1,2,3]
          7 )

    <ipython-input-1-428f22ac6c9b> in magic(self, *args, **kwargs)
         11                     return foo(self, *args, **kwargs)
         12                 else:
    ---> 13                     raise ValueError("x ({}) != y ({})".format(self.x, y))
         14                 print("end magic")
         15             return magic

    ValueError: x (4) != y (3)

Answer 6

我在研究一个非常相似的问题时发现了这个问题。我的解决方案是将问题分成两部分。首先，您需要捕获要与类方法关联的数据。在这种情况下，handler_for 会将 Unix 命令与该命令输出的处理程序关联起来。

class OutputAnalysis(object):
    "analyze the output of diagnostic commands"
    def handler_for(name):
        "decorator to associate a function with a command"
        def wrapper(func):
            func.handler_for = name
            return func
        return wrapper
    # associate mount_p with 'mount_-p.txt'
    @handler_for('mount -p')
    def mount_p(self, slurped):
        pass

现在我们已经将一些数据与每个类方法相关联，我们需要收集该数据并将其存储在类属性中。

OutputAnalysis.cmd_handler = {}
for value in OutputAnalysis.__dict__.itervalues():
    try:
        OutputAnalysis.cmd_handler[value.handler_for] = value
    except AttributeError:
        pass

Answer 7

我在某些调试情况下使用这种类型的装饰器，它允许通过装饰来覆盖类属性，而无需找到调用函数。

class myclass(object):
    def __init__(self):
        self.property = "HELLO"

    @adecorator(property="GOODBYE")
    def method(self):
        print self.property

这是装饰器代码

class adecorator (object):
    def __init__ (self, *args, **kwargs):
        # store arguments passed to the decorator
        self.args = args
        self.kwargs = kwargs

    def __call__(self, func):
        def newf(*args, **kwargs):

            #the 'self' for a method function is passed as args[0]
            slf = args[0]

            # replace and store the attributes
            saved = {}
            for k,v in self.kwargs.items():
                if hasattr(slf, k):
                    saved[k] = getattr(slf,k)
                    setattr(slf, k, v)

            # call the method
            ret = func(*args, **kwargs)

            #put things back
            for k,v in saved.items():
                setattr(slf, k, v)

            return ret
        newf.__doc__ = func.__doc__
        return newf

注意：因为我使用了类装饰器，所以即使您没有将任何参数传递给装饰器类构造函数，您也需要使用 @adecorator() 和方括号来装饰函数。

Answer 8

简单的方法。您所需要做的就是将装饰器方法放在类之外。里面还是可以用的。

def my_decorator(func):
    #this is the key line. There's the aditional self parameter
    def wrap(self, *args, **kwargs):
        # you can use self here as if you were inside the class
        return func(self, *args, **kwargs)
    return wrap

class Test(object):
    @my_decorator
    def bar(self):
        pass

Answer 9

在内部类中声明。这个解决方案非常可靠，值得推荐。

class Test(object):
    class Decorators(object):
    @staticmethod
    def decorator(foo):
        def magic(self, *args, **kwargs) :
            print("start magic")
            foo(self, *args, **kwargs)
            print("end magic")
        return magic

    @Decorators.decorator
    def bar( self ) :
        print("normal call")

test = Test()

test.bar()

结果：

>>> test = Test()
>>> test.bar()
start magic
normal call
end magic
>>>

Answer 10

与通常依赖于实例属性的“对象方法”的功能相比，“装饰器”似乎更适合修改“整个对象”（包括函数对象）的功能。例如：

def mod_bar(cls): # returns modified class def decorate(fcn): # returns decorated function def new_fcn(self): print self.start_str print fcn(self) print self.end_str return new_fcn cls.bar = decorate(cls.bar) return cls @mod_bar class Test(object): def __init__(self): self.start_str = "starting dec" self.end_str = "ending dec" def bar(self): return "bar" 输出为：

>>> import Test
>>> a = Test()
>>> a.bar()
starting dec
bar
ending dec

我有一个可能有帮助的装饰器实现

    import functools
    import datetime


    class Decorator(object):

        def __init__(self):
            pass


        def execution_time(func):

            @functools.wraps(func)
            def wrap(self, *args, **kwargs):

                """ Wrapper Function """

                start = datetime.datetime.now()
                Tem = func(self, *args, **kwargs)
                end = datetime.datetime.now()
                print("Exection Time:{}".format(end-start))
                return Tem

            return wrap


    class Test(Decorator):

        def __init__(self):
            self._MethodName = Test.funca.__name__

        @Decorator.execution_time
        def funca(self):
            print("Running Function : {}".format(self._MethodName))
            return True


    if __name__ == "__main__":
        obj = Test()
        data = obj.funca()
        print(data)

Answer 11

你可以装饰装饰器：

import decorator

class Test(object):
    @decorator.decorator
    def _decorator(foo, self):
        foo(self)

    @_decorator
    def bar(self):
        pass

Answer 12

使用静态方法并在装饰器的内部函数（包装器）中包含附加参数（self）。

class Test:

    @staticmethod
    def _decorator(f):

        @functools.wraps(f)
        def _wrapper(self, *args, **kwargs):
            # do some serious decorating (incl. calls to self!)
            print(self)
            return f(self, *args, **kwargs)

        return _wrapper

    @_decorator
    def bar(self):
        return 42

Answer 13

对于 Python 3 和 linter 来说

def methoddecorator(deco: Callable[[Any, Callable], Callable]):
"""
Decorator to implement method decorators in the same class

Example of usage:

    class A:
        @methoddecorator
        def my_methods_deco(self, method):
            @wraps(method)
            def wrapper(this: 'A', *args, **kwargs):
                # do smth
                # N.B. for instance access use this, not self!
                return method(this, *args, **kwargs)
            return wrapper

        @my_methods_deco
        def my_method(self, a, b):
            ...

"""
@functools.wraps(deco)
def wrapped_deco(method):
    return deco(NotImplemented, method)
return wrapped_deco

Answer 14

使用这个超级装饰器来修补类。

顺便说一句，这段代码不支持像

@deco(param=...)

这样的装饰器参数，但更复杂的一个可以。

def methoddecorator(deco):
"""
Decorator to implement method decorators in the same class
Supports optionally parametrized decorators

Example of usage:

    class A:
        @methoddecorator
        def my_methods_deco(self, _method=None, param1=None, param2=None):
            @wraps(method)
            def wrapper(this: 'A', *args, **kwargs):
                # do smth
                # deco params are also available here
                return method(this, *args, **kwargs)
            return wrapper

        @my_methods_deco
        def my_method1(self, a, b):
            ...

        @my_methods_deco(param1=11, param2=12)
        def my_method2(self, a, b):
            ...

"""
@wraps(deco)
def wrapped_deco(_method=None, **kwargs):
    return (
        deco(NotImplemented, _method)
        if _method is not None
        else partial(deco, NotImplemented, **kwargs)
    )
return wrapped_deco

类中的 Python 装饰器

问题描述投票：0回答：14

14个回答

最新问题

类中的 Python 装饰器

问题描述 投票：0回答：14

14个回答

最新问题

问题描述投票：0回答：14