Quelle est la différence entre les décorateurs Python et le motif décorateur?

Quelle est la différence entre "décorateurs Python" et le "motif décorateur"?

Quand devrais-je utiliser des décorateurs Python, et quand devrais-je utiliser le motif de décorateur?

Je cherche des exemples de décorateurs Python et le modèle de décorateur accomplissant la même chose.

@AcceptedAnswer

Je sais que la réponse DE Jakob Bowyer est valide. Pourtant, C'est la réponse de Strikar qui m'a fait comprendre pourquoi.

Après la réponse de Srikar et l'étude donnée ressources j'ai écrit cet exemple, afin que je puisse visualiser et comprendre les décorateurs Python et le modèle de décorateur.

Je dois être en désaccord avec les " décorateurs Python ne sont pas une implémentation du modèle de décorateur"de Strikar. Après ce que j'ai appris je suis fortement convaincu que les décorateurs Python implémentent le modèle de décorateur. juste pas de la manière classique.

Aussi , je dois ajouter que malgré le fait que Strikar a dit " les décorateurs Python ajoutent des fonctionnalités aux fonctions et méthodes au moment de la définition" Vous pouvez facilement utiliser des décorateurs Python au moment de l'exécution .

Pourtant, je marque toujours la réponse de Stiker comme acceptée, parce que cela m'a aidé à comprendre la mise en œuvre du motif de décorateur en Python .

"""
Testing Python decorators against the decorator pattern
"""
def function(string):
    return string

def decorator(wrapped):
    def wrap(string):
        # Assume that this is something useful
        return wrapped(string.upper())
    return wrap

def method_decorator(wrapped):
    def wrap(instance, string):
        # Assume that this is something useful
        return wrapped(instance, string.upper())
    return wrap

@decorator
def decorated_function(string):
    print('! '.join(string.split(' ')))

class Class(object):
    def __init__(self):
        pass
    def something_useful(self, string):
        return string

class Decorator(object):
    def __init__(self, wrapped):
        self.wrapped = wrapped
    def something_useful(self, string):
        string = '! '.join(string.split(' '))
        return self.wrapped().something_useful(string)

    @method_decorator
    def decorated_and_useful(self,string):
        return self.something_useful(string)


if __name__ == '__main__':
    string = 'Lorem ipsum dolor sit amet.'
    print(function(string))                  # Plain function
    print(decorator(function)(string))       # Python decorator at run time
    print(decorated_function(string))        # Python decorator at definition time
    a = Class()
    print(a.something_useful(string))        # Plain method
    b = Decorator(Class)
    print(b.something_useful(string))        # Decorator pattern
    print(b.decorated_and_useful(string))    # Python decorator decorated the decorator pattern