Como usar o decorador do Python com argumentos?

[

Primer sobre Decorators Python com Argumentos

Neste tutorial sobre decorators em Python, você aprenderá o que são e como criar e usá-los. Decorators fornecem uma sintaxe simples para chamar funções de ordem superior.

Por definição, um decorator é uma função que recebe outra função e estende o comportamento desta última sem modificá-la explicitamente. Isso pode parecer confuso, mas fará mais sentido depois de vermos alguns exemplos de como os decorators funcionam.

Neste tutorial, você aprenderá:

• O que significa para funções serem objetos de primeira classe
• Como definir funções para que possam ser usadas como decorators
• Quais casos de uso práticos podem ser abordados com decorators
• Como criar decorators que seguem as melhores práticas

Funções Python

Para entender decorators, primeiro você precisa entender alguns aspectos importantes de como as funções funcionam. Há muitos aspectos das funções, mas, no contexto dos decorators, uma função retorna um valor baseado nos argumentos fornecidos. Aqui está um exemplo básico:

def greet():
    return "Hello, Python!"

print(greet())  # Output: Hello, Python!

Neste exemplo simples, a função greet retorna a string “Hello, Python!“. Agora, vamos explorar alguns conceitos fundamentais para entender decorators.

Objetos de Primeira Classe

Em Python, as funções são consideradas objetos de primeira classe, o que significa que elas podem ser atribuídas a variáveis, passadas como argumentos para outras funções e até mesmo retornadas como valores de outras funções. Isso é fundamental para o entendimento dos decorators.

Funções Internas

Uma função interna é uma função definida dentro de outra função. Essa função interna é local somente para a função que a contém e só pode ser acessada dentro dessa função. Aqui está um exemplo:

def outer_function():
    def inner_function():
        return "Inside the inner function"

    return inner_function()

print(outer_function())  # Output: Inside the inner function

Neste exemplo, a função outer_function contém uma função interna chamada inner_function. A inner_function retorna a string “Inside the inner function” e é chamada dentro da outer_function. Note que inner_function só pode ser acessada dentro de outer_function.

Funções como Valores de Retorno

Uma função em Python pode ser usada como um valor de retorno de outra função. Isso significa que uma função pode retornar uma função. Aqui está um exemplo:

def hello():
    def inner():
        return "Hello, Inner Function!"

    return inner

greet = hello()
print(greet())  # Output: Hello, Inner Function!

Neste exemplo, a função hello retorna a função interna inner. A variável greet agora faz referência à função inner e, quando chamada, retorna a string “Hello, Inner Function!“.

Decorators Simples em Python

Decorators fornecem uma maneira conveniente de modificar a funcionalidade de uma função existente sem modificar seu código subjacente. Vamos começar com um exemplo básico de um decorator simples:

def uppercase_decorator(function):
    def wrapper():
        original_result = function()
        modified_result = original_result.upper()
        return modified_result

    return wrapper

def say_hello():
    return "Hello, Python!"

decorate = uppercase_decorator(say_hello)
print(decorate())  # Output: HELLO, PYTHON!

Neste exemplo, definimos um decorator chamado uppercase_decorator, que recebe uma função como argumento. A função interna wrapper é definida dentro do decorator e envolve a função original. Neste caso, a função say_hello retorna a string “Hello, Python!“. O decorator uppercase_decorator é usado para transformar essa string em letras maiúsculas. Chamamos o decorator com a função say_hello e a variável decorate agora faz referência à função modificada. Ao chamar decorate, obtemos o resultado “HELLO, PYTHON!“.

Adicionando Açúcar Sintático

Python fornece uma sintaxe especial para fazer a chamada de decorators de maneira mais conveniente. Em vez de usar a forma mais longa de atribuir a função decorada a uma nova variável, podemos simplesmente colocar um @ antes da definição da função que queremos decorar. Aqui está o exemplo anterior usando a sintaxe de adição de açúcar sintático:

def uppercase_decorator(function):
    def wrapper():
        original_result = function()
        modified_result = original_result.upper()
        return modified_result

    return wrapper

@uppercase_decorator
def say_hello():
    return "Hello, Python!"

print(say_hello())  # Output: HELLO, PYTHON!

Neste exemplo, usamos o decorator uppercase_decorator para decorar a função say_hello. Ao chamar say_hello, obtemos o mesmo resultado “HELLO, PYTHON!“. Essa sintaxe torna mais fácil para nós aplicar decorators às nossas funções e melhora a legibilidade do código.

Reutilizando Decorators

Os decorators em Python também podem ser reutilizados em várias funções. Para fazer isso, podemos usar um decorator genérico que pode ser aplicado a qualquer função. Aqui está um exemplo:

def uppercase_decorator(function):
    def wrapper():
        original_result = function()
        modified_result = original_result.upper()
        return modified_result

    return wrapper

@uppercase_decorator
def say_hello():
    return "Hello, Python!"

@uppercase_decorator
def say_goodbye():
    return "Goodbye, Python!"

print(say_hello())   # Output: HELLO, PYTHON!
print(say_goodbye())  # Output: GOODBYE, PYTHON!

Neste exemplo, aplicamos o mesmo decorator uppercase_decorator a duas funções diferentes: say_hello e say_goodbye. Ambas as funções retornam strings diferentes e, quando chamadas, produzem suas respectivas versões em letras maiúsculas.

Decorando Funções com Argumentos

Em alguns casos, podemos querer passar argumentos para nossas funções decoradas. Para isso, precisamos modificar a definição do decorator para aceitar argumentos e passá-los para a função interna. Aqui está um exemplo:

def greeting_decorator(function):
    def wrapper(name):
        result = function(name)
        modified_result = f"Hello, {result}!"
        return modified_result

    return wrapper

@greeting_decorator
def say_name(name):
    return name

print(say_name("Python"))  # Output: Hello, Python!

Neste exemplo, criamos um decorator chamado greeting_decorator que aceita um argumento name. A função interna wrapper é definida para receber esse argumento e usá-lo ao chamar a função original. Em seguida, modificamos o resultado antes de retorná-lo. Ao chamar say_name("Python"), obtemos a string “Hello, Python!“.

Retornando Valores de Funções Decoradas

Em alguns casos, podemos querer que nossas funções decoradas retornem valores. Para fazer isso, precisamos modificar a função interna dentro do decorator para retornar o resultado desejado. Aqui está um exemplo:

def uppercase_decorator(function):
    def wrapper():
        original_result = function()
        modified_result = original_result.upper()
        return modified_result

    return wrapper

@uppercase_decorator
def say_hello():
    return "Hello, Python!"

result = say_hello()
print(result)  # Output: HELLO, PYTHON!

Neste exemplo, a função interna wrapper é modificada para retornar o resultado após modificá-lo em letras maiúsculas. Ao chamar a função say_hello e atribuir o resultado a result, obtemos a string “HELLO, PYTHON!“.

Encontrando-se

Com todos esses conceitos em mente, agora você tem uma compreensão básica de como os decorators funcionam em Python e como aplicá-los às suas funções. No entanto, há muito mais a aprender nesse tópico. A seguir, discutiremos alguns exemplos do mundo real de como os decorators podem ser usados.

Alguns Exemplos do Mundo Real

Os decorators em Python são uma ferramenta poderosa e flexível que pode ser usada em várias situações do mundo real. Vamos explorar alguns exemplos para que você possa ver como os decorators podem ser úteis em seu próprio código.

Cronometrando Funções

Um exemplo comum de uso de decorators é medir o tempo de execução de uma função. Isso pode ser útil para fins de depuração ou para otimização de código. Aqui está um exemplo de como criar um decorator que cronometra uma função:

import time

def timer_decorator(function):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = function(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print("Execution time:", execution_time, "seconds")
        return result

    return wrapper

@timer_decorator
def long_running_function():
    time.sleep(5)
    return "Finished"

result = long_running_function()
print(result)  # Output: Finished

Neste exemplo, criamos um decorator chamado timer_decorator que mede o tempo de execução de uma função. A função interna wrapper recebe argumentos arbitrários com *args e **kwargs, o que permite que ele receba qualquer número de argumentos. Usando a função time.time(), medimos o tempo de início e fim da função e calculamos o tempo total de execução. Em seguida, imprimimos o tempo de execução e retornamos o resultado original. Chamando a função long_running_function, obtemos o resultado “Finished” e o tempo de execução em segundos.

Depurando Código

Outro caso de uso comum para decorators é a depuração de código. Os decorators permitem adicionar facilmente informações adicionais de depuração a uma função, como imprimir os valores de seus argumentos. Aqui está um exemplo:

def debug_decorator(function):
    def wrapper(*args, **kwargs):
        print("Function name:", function.__name__)
        print("Arguments:", args, kwargs)
        result = function(*args, **kwargs)
        return result

    return wrapper

@debug_decorator
def add_numbers(a, b):
    return a + b

result = add_numbers(2, 3)
print(result)  # Output: 5

Neste exemplo, criamos um decorator chamado debug_decorator que imprime o nome da função e seus argumentos antes de executá-la. Usando *args e **kwargs, permitimos que a função interna receba qualquer número de argumentos. Chamar a função add_numbers resulta na impressão do nome da função e de seus argumentos antes de retornar o resultado original.

Atrasando o Código

Às vezes, pode ser útil atrasar a execução de um pedaço de código. Isso pode ser usado para adicionar um atraso em um loop ou como uma forma de controle de velocidade em um programa. Vamos ver um exemplo de como criar um decorator que atrasa a execução de uma função:

import time

def delay_decorator(function):
    def wrapper(*args, **kwargs):
        time.sleep(3)
        result = function(*args, **kwargs)
        return result

    return wrapper

@delay_decorator
def say_hello():
    return "Hello, Python!"

result = say_hello()
print(result)  # Output: Hello, Python!

Neste exemplo, usamos o decorator delay_decorator para atrasar a execução da função say_hello em 3 segundos usando time.sleep(). Chamar a função resulta em um atraso de 3 segundos antes de retornar o resultado “Hello, Python!“.

Registrando Plugins

Os decorators também podem ser úteis para registrar plugins em um programa. Isso permite que você adicione funcionalidades extras ao seu programa de forma modular. Aqui está um exemplo:

plugins = []

def register_plugin(function):
    plugins.append(function)
    return function

@register_plugin
def greet_plugin(name):
    return f"Hello, {name}!"

@register_plugin
def goodbye_plugin(name):
    return f"Goodbye, {name}!"

for plugin in plugins:
    result = plugin("Python")
    print(result)

Neste exemplo, criamos uma lista vazia chamada plugins. Em seguida, definimos um decorator chamado register_plugin que adiciona a função decorada à lista de plugins. Usando o decorator register_plugin, registramos duas funções: greet_plugin e goodbye_plugin. Por fim, percorremos a lista de plugins e chamamos cada função, passando o argumento “Python”. Isso resulta na impressão das strings “Hello, Python!” e “Goodbye, Python!“.

Considerações Finais

Os decorators em Python são uma ferramenta poderosa e flexível que permite estender e modificar o comportamento de funções existentes de maneira simples e elegante. Neste tutorial, discutimos conceitos fundamentais de decorators, como criar decorators simples, reutilizar decorators, decorar funções com argumentos e retornar valores de funções decoradas. Também exploramos alguns exemplos de use cases do mundo real onde os decorators podem ser úteis. Agora que você tem uma compreensão básica dos decorators, você pode começar a aplicá-los em seu próprio código Python.

Leitura Adicional

• Documentação oficial do Python sobre decorators

Espero que este tutorial tenha sido útil para entender os decorator em Python e como usá-los em suas próprias funções. Divirta-se decorando!