你想做的事是不可能的。例如，下面的代码看起来是否有效:

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)

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

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
>>> 

简单的方法。 您所需要做的就是将decorator方法放在类之外。 你仍然可以在室内使用。

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

你可以装饰装饰器:

import decorator

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

    @_decorator
    def bar(self):
        pass

装饰器似乎更适合修改整个对象(包括函数对象)的功能，而不是对象方法的功能，后者通常依赖于实例属性。例如:

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

我在一些调试情况下使用这种类型的装饰器，它允许通过装饰来重写类属性，而不必找到调用函数。

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()来装饰函数，即使你没有向装饰器类构造函数传递任何参数。