`{0}`
`".format(func(name)) return func_wrapper my_get_text = p_decorate(get_text) print (my_get_text("John")) ``` > Saída: `` lorem ipsum, John dolor sit amet `
`  [Código de execução](https://repl.it/CXHL) Esse foi o nosso primeiro decorador. Uma função que usa outra função como argumento, gera uma nova função, aumentando o trabalho da função original e retornando a função gerada para que possamos usá-la em qualquer lugar. Para que o `get_text` seja decorado por `p_decorate` , basta atribuir _texto ao resultado de p_ decorar. ``` get_text = p_decorate(get_text) print (get_text("John")) ``` > Saída: lorem ipsum, John dolor sit amet Outra coisa a notar é que nossa função decorada leva um argumento de nome. Tudo o que tivemos que fazer no decorador é deixar o wrapper do get\_text passar esse argumento. > ### Sintaxe do Decorador do Python O Python torna a criação e o uso de decoradores um pouco mais limpos e mais agradáveis para o programador através de algum [açúcar sintático.](http://en.wikipedia.org/wiki/Syntactic_sugar) Para decorar o _texto, não precisamos obter o_ text = p _decorator (obter_ texto) Há um atalho para isso, que é mencionar o nome da função de decoração antes da função a ser decorada. O nome do decorador deve ser perpendido com um símbolo @. ``` def p_decorate(func): def func_wrapper(name): return "``{0}`
`".format(func(name)) return func_wrapper @p_decorate def get_text(name): return "lorem ipsum, {0} dolor sit amet".format(name) print get_text("John") ``` > Saída: `` lorem ipsum, John dolor sit amet `
`  [Código de execução](https://repl.it/CXHN) Agora vamos considerar que queríamos decorar nossa função get\_text por 2 outras funções para envolver uma tag div e forte em torno da saída da string. ``` def p_decorate(func): def func_wrapper(name): return "``{0}`
`".format(func(name)) return func_wrapper def strong_decorate(func): def func_wrapper(name): return "``{0}``".format(func(name)) return func_wrapper def div_decorate(func): def func_wrapper(name): return "`` lorem ipsum, John dolor sit amet `
`{0}`
`".format(func(self)) return func_wrapper class Person(object): def __init__(self): self.name = "John" self.family = "Doe" @p_decorate def get_fullname(self): return self.name+" "+self.family my_person = Person() print (my_person.get_fullname()) ``` > Saída: `` John Doe `
`  [Código de execução](https://repl.it/CXH2) Uma abordagem muito melhor seria tornar nosso decorador útil para funções e métodos. Isso pode ser feito colocando [\* args e \*\* kwargs](http://docs.python.org/2/tutorial/controlflow.html#arbitrary-argument-lists) como parâmetros para o wrapper, então ele pode aceitar qualquer número arbitrário de argumentos e argumentos de palavras-chave. ``` def p_decorate(func): def func_wrapper(*args, **kwargs): return "``{0}`
`".format(func(*args, **kwargs)) return func_wrapper class Person(object): def __init__(self): self.name = "John" self.family = "Doe" @p_decorate def get_fullname(self): return self.name+" "+self.family my_person = Person() print (my_person.get_fullname()) ``` > Saída: `` John Doe `
`  [Código de execução](https://repl.it/CXH5) ### Transmitindo argumentos aos decoradores Olhando para o exemplo anterior ao anterior, você pode notar como os decoradores no exemplo são redundantes. 3 decoradores (div _decoram, p_ decoram, strong\_decorate), cada um com a mesma funcionalidade, mas envolvendo a string com tags diferentes. Nós podemos definitivamente fazer muito melhor que isso. Por que não ter uma implementação mais geral para uma que usa a tag como uma string? Sim por favor! ``` def tags(tag_name): def tags_decorator(func): def func_wrapper(name): return "<{0}>{1}".format(tag_name, func(name)) return func_wrapper return tags_decorator @tags("p") def get_text(name): return "Hello "+name print (get_text("John")) ``` > Saída: `` Olá, John `
`  [Código de execução](https://repl.it/CXH6) Demorou um pouco mais de trabalho neste caso. Os decoradores esperam receber uma função como argumento, e é por isso que teremos que construir uma função que leve esses argumentos extras e gere nosso decorador na hora. No exemplo acima, tags, é o nosso gerador de decorador. Depuração de funções decoradas No final do dia, os decoradores estão apenas envolvendo nossas funções, no caso de depuração que pode ser problemática, já que a função wrapper não carrega o nome, módulo e docstring da função original. Baseado no exemplo acima, se fizermos: ``` print (get_text.__name__) ``` > Saída: func _wrapper A saída era esperada para ser obter_ texto ainda, os atributos **name** , **doc** e **module** de get _text foram substituídos pelos do wrapper (func_ wrapper. Obviamente podemos re-setá-los dentro de func\_wrapper mas o Python fornece muito maneira mais agradável. ### Functools para o resgate ``` from functools import wraps def tags(tag_name): def tags_decorator(func): @wraps(func) def func_wrapper(name): return "`<{0}>`{1}``".format(tag_name, func(name)) return func_wrapper return tags_decorator @tags("p") def get_text(name): """returns some text""" return "Hello "+name print (get_text.__name__) # get_text print (get_text.__doc__) # returns some text print (get_text.__module__) # __main__ ```  [Código de execução](https://repl.it/CXHb) Você pode notar na saída que os atributos de get\_text são os corretos agora.