Phenquestions
Definição: Decorator é um padrão de design em Python. É uma função que recebe outra função como argumento, adiciona alguma funcionalidade a ela sem modificá-la e retorna outra função.
Isso é chamado usando “(@)” e colocado antes de definir uma função que queremos decorar.
sintaxe:
@decorator name
Definição de função
Para entender os decoradores, precisamos conhecer os conceitos abaixo.
Funções são objetos de primeira classe. Significa que uma função pode ser passada como um argumento, pode ser retornada de outra função, pode ser atribuída a uma variável, pode ser definida em outra função. Para um melhor entendimento, veja os exemplos abaixo.
- Uma função pode ser passada como um argumento
Ex: incremento de def (n):
retornar n + 1
def demo_funcall (função):
num = 5
função de retorno (num)
demo_funcall (incremento)Aqui, a função de incremento é passada como um argumento
Exemplo 1.py:
Resultado:
>> python example1.py
- A função pode ser retornada de outra função
Ex: def wish ():
def say_wish ():
retornar "feliz aniversário"
retornar say_wish
olá = desejo ()
Olá()exemplo 2.py:
Resultado:
>> python example2.py
Aqui, a função say_wish retornada da função de desejo - A função pode ser modificada e atribuída a uma variável
Ex: def add (a, b):
retornar a + b
sum2nos = adicionar # Aqui adicionar função atribuída à variável
sum2nos (5,11)exemplo 3.py:
Resultado:
>> python example3.py
- Definir função dentro de outra função
Ex: def add (a, b):
def sum2 (a, b):
retornar a + b
res = soma2 (a, b)
retornar res
adicionar (10,15)exemplo 4.py:
Resultado:
>> python example4.py
Fecho:
Python permite que uma função aninhada acesse o escopo externo da função envolvente.
saudação def (mensagem):"Função Enclosong"
def send_greeting ():
"Função aninhada"
imprimir (mensagem)
send_greeting ()
saudação ("bom dia")
exemplo 5.py:
Resultado:
>> python example5.py
Depois de entender os conceitos acima agora, vamos escrever um exemplo de decorador.
Ex1: Aqui, vamos decorar a função da mensagem. Imprimindo a mensagem dentro de **** sem modificar a função original, i.e., função de mensagem.
#decorator startdef print_msg (função):
def wrapper ():
função()
embalagem de retorno
#decorator end
def message ():
imprimir (“Este é o primeiro exemplo para demonstrar o decorador”)
olá = print_msg (mensagem)
Olá()
exemplo 6.py:
Resultado:
>> python example6.py
Na forma mais simples, podemos colocar o decorador no topo da definição da função e chamar a função conforme mostrado abaixo:
Aqui, qualquer string que queremos decorar dentro de ***, use este decorador.
Resultado:
Vários decoradores:
Podemos ter vários decoradores para uma única função. Aqui, o decorador é aplicado na ordem que chamamos.
sintaxe:
@ decorator2
@ decorator1
Definição de função
Aqui, o primeiro decorador será aplicado, depois o segundo decorador.
Passando argumentos para funções de decorador:
Podemos passar argumentos para a função wrapper. Os argumentos passados para a função para a qual queremos decorar.
Ex:
def deco_wish (função):def wrapper (arg1, arg2):
print ('Os argumentos passados são', arg1, arg2)
impressão ('*********************')
função (arg1, arg2)
impressão ('*********************')
embalagem de retorno
@deco_wish
def desejo (a1, a2):
imprimir (a1, a2)
desejo ('Bom', 'Dia')
desejo ('Bom', 'Tarde')
exemplo 7.py:
Resultado:
>> python example7.py
Passe um número variável de argumentos para a função decoradora:
Podemos passar qualquer número de argumentos usando * args (argumentos sem palavra-chave como números) e ** kwargs (argumentos de palavra-chave como um dicionário). Ambos são argumentos posicionais e armazenam os argumentos nas variáveis args e kwargs.
Observação: aqui, podemos usar qualquer nome em vez de args e kwargs, mas recomendamos o uso desses nomes.
Ex:
def dec_var_args (função):def wrapper (* args, ** kwargs):
print ('Os argumentos sem palavra-chave são', args)
print ('Os argumentos de palavra-chave são', kwargs)
função (* args)
embalagem de retorno
@ dec_var_args
def fun_non_key_args (* args):
para I em args:
imprimir (i)
@ dec_var_args
def fun_key_args ():
imprimir (“argumentos de palavra-chave”)
fun_non_key_args ((4,5,6))
fun_key_args (fname = 'Anand', lname = 'Matemática')
exemplo 8.py:
Resultado:
>> python example8.py
Ex2: Suponha que temos 2 funções
Função1: Calcular a soma dos números da lista fornecida
Função2: Multiplique cada número por 2 e adicione-os à lista de números fornecida
Se quisermos calcular o tempo que cada um leva para a execução, podemos fazê-lo de 2 maneiras
- Coloque o código entre o horário de início e término de cada função
- Escreva decorador para calcular o tempo
Veja abaixo o código resolvido usando decorador:
#decorator startexe_time_calc (func):
def wrapper (arg):
start_time = datetime.data hora.agora()
função (arg)
end_time = datetime.data hora.agora()
print ("O tempo que leva para executar a função" + func.__name__ + "é" + str (end_time - end_time))
embalagem de retorno
#decorator end
@exe_time_calc
def cal_avg (dados):
soma = 0
para i em dados:
soma + = i
print ("A média de determinada lista de números é", soma // len (dados))
@exe_time_calc
def mul_by_2 (dados):
soma = 0
para i em dados:
soma + = + (i * 2)
print ("A soma de todos os números após a multiplicação por 2 é", soma)
cal_avg ([10,20,30,40,50])
mul_by_2 ([10,20,30,40,50])
exemplo9.py:
Resultado:
>> python example9.py
O decorador acima pode ser usado para calcular o tempo de execução de qualquer uma das funções. Ao usar um decorador, podemos evitar código repetido quando temos um requisito para calcular o tempo de execução para colocar o decorador acima da definição da função.
Conclusão:
Os decoradores mudam a funcionalidade de uma função / método sem mudar o código original da função que está sendo decorada. Usando isso, podemos evitar escrever código repetido. Conhecer o conceito de decorador nos tornará fortes em python. Podemos usar decorator nos casos abaixo:
- Autorização em frameworks Python Ex: Flask e Django
- Exploração madeireira
- Medir o tempo de execução
