Are Python decorators necessary?

Question

I have a basic understanding of decorators, but as yet they seem superfluous and "hacky", like C macros but for functions.

An article stressing the importance of decorators gives this example of decorator usage:

from myapp.log import logger

def log_order_event(func):
    def wrapper(*args, **kwargs):
        logger.info("Ordering: %s", func.__name__)
        order = func(*args, **kwargs)
        logger.debug("Order result: %s", order.result)
        return order
    return wrapper

@log_order_event
def order_pizza(*toppings):
    # let's get some pizza!

order_pizza(*toppings) # Usage

Isn't this equivalent to the decoratorless code below?

from myapp.log import logger

def log_order_event(func, *args, **kwargs):
    logger.info("Ordering: %s", func.__name__)
    order = func(*args, **kwargs)
    logger.debug("Order result: %s", order.result)
    return order

def order_pizza(*toppings):
    # let's get some pizza!

log_order_event(order_pizza, *toppings) # Usage

In fact, isn't the second snippet easier to write since it's one function instead of a function and a wrapper function? The usage calls are longer, but they more clearly indicate what's actually being called.

Is it purely a matter of taste and syntactic sugar, or am I missing something?

Answer 1

Both snippets are equivalent as far as behavior is concerned. However, I'd use the decorator version for two main reasons:

1. Readability: With snippet 2, you'd require an explicit function call to a less relevant method log_order_event() whose main purpose is logging. This logging functionality may be required by other methods such as order_appetizers() and therefore, you would require individual calls to log_order_event() for every such method. Wouldn't it be better(from a readability perspective) to have a wrapper defined once & for all, that performs logging and you may call the wrapper(as a decorator) for such methods whenever necessary? Decorators are syntactic sugar but certainly not a hack. In fact, PEP 318 clearly talks about the motivation behind decorators, you must read that.

2. Scalability: Consider a situation where your code has several methods(say 20) such as order_appetizers(), order_maincourse(), order_desserts() and so on. Let's also assume that you'd like to perform some prior checks before ordering any of these items, say check for toppings(for pizza's), calories(for desserts) and so on. When using decorators, its just a matter of defining the wrapper functions in a separate wrapper class for each check, import it in your main code and decorate the required methods respectively. That way, your wrapper functions are completely isolated and the main logic remains clean and easy to maintain.

   @check_toppings
   @log_order_event
   def order_pizza(*toppings):
       # let's get some pizza!
   
   @check_calories
   @log_order_event
   def order_desserts():
       # let's order some desserts!
   ...and so on for 20 more methods
   

   With a decoratorless logic, while you can separate the check(and log) methods in a separate class and import in your main logic, you would still have to add individual calls to each of these methods inside each order method which from a code maintenance perspective could prove to be daunting, especially for new eyes.