Python décorateurs dans les classes

Ce que vous êtes désireux de le faire n'est pas possible. Prenez, par exemple, de savoir si ou non le code ci-dessous est valide:

class Test(object):

    def _decorator(self, foo):
        foo()

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

Bien sûr, n'est pas valide, car self n'est pas défini à ce stade. Il en va de même pour Test que ce ne sera pas défini jusqu'à ce que la classe elle-même est définie (ce qui son dans le processus d'). Je vous montre cet extrait de code, parce que c'est ce que votre décorateur d'extrait de transforme en.

Donc, comme vous pouvez le voir, l'accès à l'instance dans un décorateur, comme ce n'est pas vraiment possible, car les décorateurs sont appliquées lors de la définition de ce que la fonction/méthode qu'ils y sont attachés, et non lors de l'instanciation.

Si vous avez besoin d' de classe-niveau d'accès, essayez ceci:

class Test(object):

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

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

C'est un chemin que je connais (et utilisé) pour accéder à self de l'intérieur d'un décorateur définie à l'intérieur de la même classe:

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

De sortie (testé sur 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'

L'exemple ci-dessus est idiot, mais montre qu'il fonctionne.

J'ai trouvé cette question alors que des recherches sur un problème très similaire. Ma solution est de diviser le problème en deux parties. Tout d'abord, vous avez besoin pour capturer les données que vous souhaitez associer avec les méthodes de la classe. Dans ce cas, handler_for va associer une commande Unix avec le gestionnaire pour que la sortie de la commande.

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

Maintenant que nous avons associé des données avec chaque méthode de la classe, nous avons besoin de recueillir des données et de les stocker dans un attribut de classe.

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

Voici une expansion sur Michael Speer, en réponse à la prendre un peu plus loin:

Une méthode d'instance décorateur qui prend des arguments et des actes sur une fonction avec des arguments et une valeur de retour.

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

Et puis

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)

J'ai une mise en Œuvre de Décorateurs qui Pourrait l'Aider à

    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)