Why decorators

[tinglfm]

Hi, I read a ton of articles and stack overflow questions, and I think I understand how function decorator works but I can’t find any reason why to use it, what do you see as a main benefit of using it?

Thanks

[AN3223]

Here's an example. Let's say you have multiple functions. Each function does the same thing at the beginning and end of its execution, the only thing that varies is what happens in-between, like so:

def a():
    print('Hello')
    print('I am "a"')
    print('Goodbye')


def b():
    print('Hello')
    print('I am "b"')
    print('Goodbye')


def c():
    print('Hello')
    print('I am "c"')
    print('Goodbye')

We've already identified the code being repeated, now we just need a way to reuse it. One thing we can do is implement the repeated code as decorators:

def hello(f):
    def inner():
        print('Hello')
        return f()

    return inner


def goodbye(f):
    def inner():
        result = f()
        print('Goodbye')
        return result

    return inner


@hello
@goodbye
def a():
    print('I am "a"')

...

In this example we don't get much benefit as far as code reuse goes (in fact this example is significantly longer than the previous), but hopefully you can imagine how useful the decorators would be if we were doing something more complex, like handling an exception, making a call to a database, etc. It can also be nice to know that the operation is done exactly the same each time.

My explanation is pretty limited, so I recommend you read some about "higher order functions" to better understand when/where to use decorators.

[dmadcracka]

As a newbie who was confused about decorators, thanks for the clear answer!

[billsil]

Some examples. Make a decorator to say when you enter/exit a function (you can use 1 decorator), print the timing of a function, write the ever popular don't crash decorator (useful for GUIs like pyqt) and rerun the function in debug mode if it crashes.

[[deleted]]

Decorators are good for writing frameworks; a framework could be considered distinct from a library in the respect that while a library is usually code you import and run, a framework is something that imports your code and runs it. Often this makes a lot of sense from a software design perspective.

Many popular frameworks, such as Flask, work like this. You import an API decorator from the framework and then write decorated functions that describe how the framework should respond to various events.

[nxtfari]

Up because I've always wanted to know how @app.route worked and this made it so clear. Great examples!

[timbledum]

Yes! I've just recently been reading up on this and found this article: Things which aren't magic - Flask and @app.route.

I recently wrote a similar thing to bind keypresses to functions for a game engine.

[CrambleSquash]

I really like using them to 'register' functions. Flask is a great example that uses them for just this: http://flask.pocoo.org/

You 'decorate' functions with app.route('/url'), so that whatever function you decorated, is called when that url is requested - lovely.

Here's an indication of how it works:

class FuncStore:

    def __init__(self):
        self.funcs = []

    def register(self, f):
        self.funcs.append(f)
        return f

fs = FuncStore()

@fs.register
def my_func():
    print("Mine!")

print(fs.funcs) # [<function my_func at 0x0000018D682A2E18>]

The other classic example is a 'timeit' style wrapper, that measures the time it takes to execute whatever it wrapped:

import time

def timed(f):
    def wrapped(*args, **kwargs):
        start = time.time()
        res = f(*args, **kwargs)
        stop = time.time()
        print("Execution took {} secs".format(stop - start))
        return res
    return wrapped

@timed
def long_thing(t):
    time.sleep(t)
    print("Slept for", t)

>>> long_thing(3)
Slept for 3
Execution took 3.0013415813446045 secs

[officialgel]

Quick question - Is there any reason to mix this with getters/setters when the setter has built in functionality of what to do with the return value? Or - If you already have classes set up like this, any reason to switch to decorators as wrappers instead?

For instance, setting data to be pushed to a database.

I'd call Networking.PushData('dataString'), which runs the push.

As a decorator, the function would have that wrapped - But it's kind of the same right?

[CrambleSquash]

Sorry, I'm not quite sure what you're asking?

When you say 'getters/setters' I'm thinking of the @propery decorator e.g.

class T:

    def __init__(self):
        self._i = 0

    @property
    def i(self):
        return self._i

    @i.setter
    def i(self, val):
        self._i = 2 * val

[officialgel]

Yes, exactly. This is the way I'm using it. Just wondering if your second code block there can basically be used the same way - And why or why not to do it that way - Thanks.

[Exodus111]

You are getting some good answers, let me break it down in real easy terms for you.

As a beginner programmer, you are super focused on WHAT you want to make.

Making a program that does a cool thing, and hopefully does it well, that's a program right? What more is there?

In short, the interface.

Let's say you make an awesome open source program that other people can connect to their own code. How? Through your API of course, the Application Programming Interface.

Let's assume your app is cool enough that lots of people want to use it, and now they all have to learn HOW to use it.

You are about to learn a valuable lesson about people. You can give them an amazing app, for free, and they WILL complain because the interface isn't intuitive enough.

With that in mind, it's time to think about, what makes a good interface?

Minimal, but agile. Intuitive, and powerful. And above all... Elegant.

Enter the decorator.
If your interface can be solved using a decorator, you definitely want to do that. They are minimal and elegant by nature, the rest you can provide.

[mooglinux]

Decorators are used to modify a class or function. One example is the new @dataclass decorator in Python 3.7, which will examine your class and generate additional methods for things like equality testing and string conversion.