La mise en œuvre du décorateur modèle en Python

Je veux mettre en œuvre les décorateur modèle en Python, et je me demandais si il y a une façon d'écrire un décorateur qui vient de implémente la fonction qu'il souhaite modifier, sans avoir à écrire de la chaudière-plaque pour toutes les fonctions qui sont simplement transmis à l'objet décoré. Comme:

class foo(object):
    def f1(self):
        print "original f1"
    def f2(self):
        print "original f2"

class foo_decorator(object):
    def __init__(self, decoratee):
        self._decoratee = decoratee
    def f1(self):
        print "decorated f1"
        self._decoratee.f1()
    def f2(self):              # I would like to leave that part out
        self._decoratee.f2()

Je voudrais avoir des appels à foo_decorator.f2 transmis à decoratee.f2 automatiquement. Est-il possible d'écrire une méthode générique qui transfère toutes les mises au placard de la fonction-les appels à decoratee?

  • Pouvez-vous donner un exemple où tout simplement sous-classement, pas de travail? Vous pouvez sous-classe dynamiquement trop - ce modèle semble comme une solution de contournement pour les langues qui ne peuvent pas le faire ou ne prennent pas en charge plusieurs part de l'héritage.
  • Je veux décorer des objets lors de l'exécution. Je veux appliquer différents décorateurs d'un objet et d'être en mesure de les supprimer. Sous-classement ne peut pas changer l'instance après qu'il a été créé, ou peut-il?
  • Si vous avez de la classe A et changement A, c'est à dire l'ajout d'une nouvelle méthode, A.foo = lambda self: self cela vous permettra de réfléchir sur toutes les instances d'Un .. parce que tout est déterminé au moment de l'exécution. Excellente façon de produire absolument difficile à maintenir le code.
  • Le décorateur modèle (contrairement à python décorateurs) est utilisé pour ajouter un comportement à un objet lors de l'exécution. C'est en fait très facile à gérer, quand il est fait correctement, c'est pourquoi j'ai posté cette question. Je voulais trouver le moyen de cette en Python.
InformationsquelleAutor Björn Pollex | 2010-06-25
  1. 32

    Vous pouvez utiliser __getattr__:

    class foo(object):
    def f1(self):
        print "original f1"
    def f2(self):
        print "original f2"

class foo_decorator(object):
    def __init__(self, decoratee):
        self._decoratee = decoratee
    def f1(self):
        print "decorated f1"
        self._decoratee.f1()
    def __getattr__(self, name):
        return getattr(self._decoratee, name)

u = foo()
v = foo_decorator(u)
v.f1()
v.f2()
    • C'est une excellente idée. Il convient de noter, cependant, que si vous utilisez les Classes de Base Abstraites (c'est à dire à l'importation abc et utiliser métaclasse = abc.ABCMeta de définir des méthodes abstraites et propriétés), alors il ne fonctionnera pas.
    • Cela ne fonctionne pas pour des fonctions comme str. Ce qui s'y passe?
    • La redirection ne fonctionne pas pour le trait de soulignement double méthodes, parce que ceux-ci doivent (pour des raisons de performances) être définie sur la classe, et non l'instance. (plus d'infos) je crois que la seule solution est de définir de manière explicite et rediriger les méthodes comme __str__.
    • Est-ce vraiment la "accepté" la façon de mettre en place le pattern décorateur? L'écrasement d'un "trait de soulignement double" méthode se sent hacky.
    InformationsquelleAutor Philipp
  2. 9

    Comme un additif à Philipp réponse; si vous avez besoin non seulement de décorer, mais de préserver la type d'un objet, Python permet à la sous-classe d'une instance au moment de l'exécution:

    class foo(object):
    def f1(self):
        print "original f1"

    def f2(self):
        print "original f2"


class foo_decorator(object):
    def __new__(cls, decoratee):
        cls = type('decorated',
                   (foo_decorator, decoratee.__class__),
                   decoratee.__dict__)
        return object.__new__(cls)

    def f1(self):
        print "decorated f1"
        super(foo_decorator, self).f1()


u = foo()
v = foo_decorator(u)
v.f1()
v.f2()
print 'isinstance(v, foo) ==', isinstance(v, foo)

    C'est un peu plus complexe que ce qui est strictement nécessaire pour votre exemple, où vous savez que la classe d'être décoré à l'avance.

    Ce pourrait suffire:

    class foo_decorator(foo):
    def __init__(self, decoratee):
        self.__dict__.update(decoratee.__dict__)

    def f1(self):
        print "decorated f1"
        super(foo_decorator, self).f1()
    • Cela semble exécuter le decoratee de __init__() de nouveau, passant decoratee, ce qui est probablement ce n'est pas souhaitée.
    InformationsquelleAutor Alec Thomas
  3. 2

    C'est sans doute pas la meilleure pratique, mais vous pouvez ajouter des fonctionnalités à des instances, comme je l'ai fait pour aider à la transition de mon code à partir de l'ORM de Django à SQLAlachemy, comme suit:

    def _save(self):
    session.add(self)
    session.commit()
setattr(Base,'save',_save)
    • J'ai estimé que c'était bien, mais il se sent très mal pour moi. Peut-être que c'est parce que je viens du C++?
    • Il est juste de se sentir mal à ce sujet. Il pourrait être considéré comme monkey patching. Cependant, il fonctionne bien avec peu de code, c'est un monde très différent, avec plus de possibilités de C quand tout est dynamique & par référence.
    • Je l'aime. Pour cet exemple, tout le reste serait juste d'introduire plus de la complexité de l'OMI.
    InformationsquelleAutor andyortlieb
  4. 2

    Le diagramme UML dans la Wikipedia article est faux et est donc votre code.

    Si vous suivez le "pattern décorateur", le décorateur classe est dérivée à partir de la base décorée de classe. (Dans le diagramme UML est un héritage de la flèche à partir de la WindowDecorator à la Fenêtre est manquant).

    avec

    class foo_decorator(foo):

    vous n'avez pas besoin de mettre en œuvre sans décor méthodes.

    BTW: Dans les langages à typage fort, il est une raison de plus pourquoi le décorateur doit être dérivée de la salle de classe: Sinon vous ne seriez pas en mesure de la chaîne de décorateurs.

    • Le diagramme UML montre à la fois l'héritage et d'agrégation (deux parties essentielles de décorateur pattern) de la classe de base. Vous héritez de la classe de base, de sorte que vous ressembler à l'original, et vous tenez une référence à une instance de la classe de base où vous pouvez vous isoler accès. L'article de wikipedia dit dans les étapes 1 et 2: "(1) la sous-classe le Composant d'origine, (2) ajouter un Composant pointeur comme un champ". Si la question d'origine est en fait sur Python duck-typing, et ni sur le décorateur patter, ni Python décorateurs!
    InformationsquelleAutor IanH
  5. 0

    Pour compléter @Alec Thomas réponse. J'ai modifié sa réponse à suivre le pattern décorateur. De cette façon, vous n'avez pas besoin de connaître la classe que vous soyez à la décoration à l'avance.

    class Decorator(object):
    def __new__(cls, decoratee):
        cls = type('decorated',
                   (cls, decoratee.__class__),
                   decoratee.__dict__)
        return object.__new__(cls)

    Ensuite, vous pouvez l'utiliser comme:

    class SpecificDecorator(Decorator):
    def f1(self):
        print "decorated f1"
        super(foo_decorator, self).f1()

class Decorated(object):
    def f1(self):
        print "original f1"


d = SpecificDecorator(Decorated())
d.f1()
    InformationsquelleAutor synack
  6. 0

    Dans un de mes projets, j'ai aussi besoin de faire une chose en particulier, c'est que même l'objet sous-jacent doit donc exécuter la méthode qui a été réimplémentée dans le décorateur. Il est en fait assez facile à faire si vous savez où la cible.

    Le cas d'utilisation est:

    • J'ai un objet X avec les méthodes A et B.
    • J'ai créer un décorateur classe Y qui remplace A.
    • Si j'instancie Y(X) et appeler Un, il va utiliser la décorées comme prévu.
    • Si B appelle Une, alors si j'instancie Y(X) et B sur le décorateur, l'appel à partir de l'intérieur de B se dirige ensuite vers le vieux Une sur l'objet d'origine qui n'était pas souhaitable. Je veux que le vieux B à appeler la nouvelle A ainsi.

    Il est possible d'atteindre ce comportement comme ceci:

    import inspect
import six      # for handling 2-3 compatibility

class MyBaseDecorator(object):
    def __init__(self, decorated):
        self.decorated = decorated

    def __getattr__(self, attr):
       value = getattr(self.decorated, attr)
       if inspect.ismethod(value):
           function = six.get_method_function(value)
           value = function.__get__(self, type(self))
       return value

class SomeObject(object):
    def a(self):
        pass

    def b(self):
        pass

class MyDecorator(MyBaseDecorator):
    def a(self):
        pass

decorated = MyDecorator(SomeObject())

    Cela peut ne pas fonctionner hors de la boîte que j'ai tapé tout le reste en dehors de la getattr méthode à partir du haut de ma tête.

    Le code ressemble à la demande de l'attribut dans l'objet décoré, et si c'est une méthode (ne fonctionne pas pour les propriétés à présent, mais le changement de support ne devrait pas être trop difficile), le code puis tire la fonction réelle de la méthode et de l'utilisation du descripteur d'interface d'invocation il "relie" la fonction comme une méthode, mais d'un décorateur. Alors il est retourné et probablement exécuté.

    L'effet de ceci est que si b jamais les appels a sur l'objet d'origine, puis, quand vous avez de l'objet décoré et il est tout appel de méthode en provenance du décorateur, le décorateur permet de s'assurer que toutes les méthodes d'accès sont liés à des le décorateur au lieu de cela, donc à la recherche de choses à l'aide de la décoratrice et pas l'objet d'origine, donc les méthodes spécifiées dans le décorateur prioritaires.

    P. S.: Oui, je sais, il ressemble plutôt à la succession, mais cette façon de faire dans le sens de la composition de plusieurs objets.

    InformationsquelleAutor Milan Falešník