Quelque chose comme ça ferait ce dont vous avez besoin?
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()
Cela évite l'appel à soi pour accéder au décorateur et le laisse caché dans l'espace de noms de classe comme une méthode régulière.
>>> import stackoverflow
>>> test = stackoverflow.Test()
>>> test.bar()
start magic
normal call
end magic
>>>
modifié pour répondre à la question dans les commentaires:
Comment utiliser le décorateur caché dans une autre classe
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
Production:
Normal:
start magic
normal call
end magic
Inherited:
start magic
override bar in
start magic
normal call
end magic
override bar out
end magic
Ce que vous voulez faire n'est pas possible. Prenez, par exemple, si le code ci-dessous semble valide ou non:
Cela, bien sûr, n'est pas valide car
self
n'est pas défini à ce stade. Il en va de mêmeTest
car elle ne sera pas définie tant que la classe elle-même ne sera pas définie (dont elle est en train de l'être). Je vous montre cet extrait de code, car c'est ce que votre extrait de code de décorateur transforme.Ainsi, comme vous pouvez le voir, accéder à l'instance dans un décorateur comme celui-ci n'est pas vraiment possible car les décorateurs sont appliqués pendant la définition de la fonction / méthode à laquelle ils sont attachés et non pendant l'instanciation.
Si vous avez besoin d' un accès au niveau de la classe , essayez ceci:
la source
la source
@foo
, pas@foo()
wrapper
êtreself
?J'utilise ce type de décorateur dans certaines situations de débogage, il permet de surcharger les propriétés de classe en décorant, sans avoir à trouver la fonction appelante.
Voici le code du décorateur
Remarque: parce que j'ai utilisé un décorateur de classe, vous devrez utiliser @adecorator () avec les crochets pour décorer les fonctions, même si vous ne passez aucun argument au constructeur de la classe du décorateur.
la source
C'est une façon d'accéder (et d'avoir utilisé)
self
depuis l'intérieur d'undecorator
défini à l'intérieur de la même classe:Sortie (testé sur
Python 2.7.10
):L'exemple ci-dessus est idiot, mais cela fonctionne.
la source
J'ai trouvé cette question en recherchant un problème très similaire. Ma solution est de diviser le problème en deux parties. Tout d'abord, vous devez capturer les données que vous souhaitez associer aux méthodes de classe. Dans ce cas, handler_for associera une commande Unix au gestionnaire pour la sortie de cette commande.
Maintenant que nous avons associé certaines données à chaque méthode de classe, nous devons rassembler ces données et les stocker dans un attribut de classe.
la source
Voici une extension de la réponse de Michael Speer pour aller plus loin:
Un décorateur de méthode d'instance qui prend des arguments et agit sur une fonction avec des arguments et une valeur de retour.
Puis
la source
Les décorateurs semblent mieux adaptés pour modifier la fonctionnalité d'un objet entier (y compris les objets de fonction) par rapport à la fonctionnalité d'une méthode d'objet qui dépendra en général des attributs d'instance. Par exemple:
La sortie est:
la source
Vous pouvez décorer le décorateur:
la source
J'ai une implémentation de décorateurs qui pourraient aider
la source
Déclarez en classe interne. Cette solution est assez solide et recommandée.
Le résultat:
la source