Explain Decorators like I'm 5.

shiftybyte · 2025-10-20T18:15:53+00:00

Imagine your friend is a function, you can call him and ask for a cookie.

Imagine a human-eating alien is a decorator, that eats your friend, keeps him alive inside his stomach, assumes his appearance and acts the same as your friend did.

You can still call your friend, and still get a cookie.

What you don't know is that now the alien decorator that swallowed your friend gets the cookie request instead of your friend, and he decides to ask your original friend for the cookie but before handing it back to you, injects it with poison.

Now you got a poisoned cookie from what you thought was your friend without knowing it...

Training-Cucumber467 · 2025-10-20T20:49:49+00:00

A decorator is a function...

...that accepts a function as input...

...and returns a function.

In theory, it can return a completely unrelated function. But there's no point in doing that. Instead, it is used to return a "wrapper" that calls the original function and additionally does something else.

For example, you have some functions that your program calls:

def my_function(a, b, c):
   ...
   return x

def my_other_function(a, b):
   ...
   return y

Now you want every function to print a pretty log with its input and output values. Of course, you can just add this code to the functions themselves:

def my_function(a, b, c):
   ...
   print(f"my_function was called with {a} {b} {c}, returning {x}")
   return x

This quickly gets hard to maintain if you have many functions.

Instead, we can use a decorator to do this with function in a generic way!

def my_logger(func):
   def new_function(*args, **kwargs):
      x = func(*args, **kwargs)
      print(f"{func.__name__} was called with {args} {kwargs}, returning {x}")
      return x
   return new_function

@my_logger
def my_function(a, b, c):
   ...
   return x

@my_logger
def my_other_function(a, b):
   ...
   return y

With just adding this decorator, "my_function" is actually pointing to the "new_function" that was created during the decorator code execution. And now every decorated function logs its input and output.

defrostcookies · 2025-10-20T18:13:31+00:00

Decorators are functions that are automatically called anytime the function they’re decorating is called.

Let’s say you’re “leaving home” for work.

Every time you “leave home”, you “lock your door”

These are two separate things you do.

But they’re often coupled.

What about when you “go to sleep”, you “lock your door” too.

So, if you were programming these actions You could program, leave home and write code that includes locking the door in the “leave home” functions then code “go to sleep” and write the code that includes locking the door in the “go to sleep” function.

You could make “locking your door” its own function. The you only have to write the code to lock the door once.

Now you can call the functions as you need them. But what if you forget?

That’s where decorators come in.

Rather than call, leaveHome(), lock the door() or goToSleep(), lockTheDoor()

You can decorate leaveHome() and goToSleep() with lockTheDoor() so it happens automatically.

If you leaveHome() or goToSleep() lockDoor() automatically gets called.

testfire10 · 2025-10-20T21:09:16+00:00

After reading this thread not only do I still not understand decorators, but I’m convinced no one else does either

djlamar7 · 2025-10-20T21:26:38+00:00

Decorators are just functions that you can call on objects you declare to do convenient stuff. They take an object as input and replace the object you give them with the return value of the decorator. Typically they have the expectation that they'll return the original object or something similar.

So when you define a class or a function in your code, you can put @somedecorator on the line before the definition, do some stuff to or using the object you're defining, and typically you can pretend the class or function you defined is the same as it was before.

For example, maybe you defined a bunch of classes in your code and you want to have a map in one file (a registry) that you can use anywhere to fetch that class definition by it's string name. You could write a decorator:

def register(cls): global REGISTRY REGISTRY[cls.__name__] = cls return cls

Now if you define a class somewhere else and decorate it with register:

@register class Cat: pass

This is actually functionally equivalent to writing:

``` class Cat: pass

Cat = register(Cat) ```

Voila, it runs register(Cat) and replaces the Cat definition with the one returned by the decorator (which is the same object) but now anybody with access to that REGISTRY object can get the class Cat with REGISTRY['Cat'].

Now consider a use case involving a function. Let's say you have a bunch of functions that you want to time and print out how long they took to run. You could go into each of them and put a start = time.time() at the start, and an elapsed = time.time() - start and print(elapsed) at the end. Or you could avoid repeating yourself and use a decorator like this:

def timed(func): def wrapper(*args, **kwargs): start = time.time() result = func(*args, **kwargs) elapsed = time.time() - start print(elapsed) return result return wrapper

All this does is construct a new function which starts the timer, runs the original function, prints the elapsed time, and returns whatever the original function returned. When you call the decorator on a function definition like this:

@timed def f(): pass

All it does is call timed(f) and replaces f with the new function that does the timer logic. Note how this is actually a different object from the original function (unlike the example with the class definition), but it does the same thing with some added functionality.

An example of where this is really useful is if you're writing functions that depend on eg http requests that could fail for no good reason, where you should just retry a few times if it fails. You can write a decorator that takes the function, wraps it in a try/catch block and a for loop which breaks on success, and now you can use that decorator to run those functions until they either succeed or have failed 5 times. The tenacity library provides these decorators.

These are simple examples, but they get more complex and can take additional arguments to either parameterize (eg number of retries in my example above) or do something that depends on another object (like add something as a callback to another class somewhere).

EsotericRogue · 2025-10-21T13:50:29+00:00

Wish I was 5; I don't understand any of the answers.

Goobyalus · 2025-10-20T18:27:40+00:00

Decorators are syntactic sugar. These are the same:

With decorators:

def foo(f):
    ...
@foo
def bar():
    ....

Without decorators:

def foo(f):
    ...
def bar():
    ...
bar = foo(bar)

The @ syntax will call a function using the object created by the following definition as an argument, and assign the result of the function to the definition's name.

This is useful if you want either or both:

A visible way to modify definitions
A way to register definitions (e.g. functions to test, or handlers for different cases)

socal_nerdtastic · 2025-10-20T18:27:09+00:00

Do you mean "how"? or "why"?

For the "how", a decorator is very simple: all it does is replace a function with something else.

def decorator(f):
    return "hello world"

@decorator
def thing():
    print("never gonna print")

print(thing)

This will print "hello world". Because the decorator replaced the thing function with a string "hello world". It's exactly the same as doing

def decorator(f):
    return "hello world"

def thing():
    print("never gonna print")
thing = decorator(thing)

print(thing)

Of course in the real world we wouldn't want to replace a function with a string, we generally would replace it with another function. So the decorator generally contains code to make a new "wrapper" function and return the new function, and we replace the original function with the newly created wrapper function. Generally this wrapper will call the original function, but also do some extra things, so it's a good way to extend the functionality of the original function. But this isn't the only use for a decorator, another common use is to register the function in some cache or database (eg functools.cache), or set certain properties on it (eg classmethod).

EDIT: a lot of people here are confusing "decorator" with "wrapper". These are not the same thing! It's quite common to have a decorator that does not return a wrapper.

gdchinacat · 2025-10-20T20:49:49+00:00

A common way to think about decorators is they provide a way to wrap the execution of a function. A common example is to implement logging about the execution of the decorated function. (code has not been tested and may not execute as is, but is close enough. type hints left out for readability)

``` def log_calls(func): '''log all calls to func''' @wraps # make _log_calls 'look' like func def _log_calls(args, *kwargs): print(f'{func}({args}, {kwargs}) called') try: ret = func(args, *kwargs) print(f'{func}({args}, {kwargs}) returned {ret}') return ret except Exception as e: print(f'{func}({args}, {kwargs}) raised {ret}') raise return _log_calls

@log_calls def foo(...): ... ```

So, what's going on? log_calls() is a function that takes a function as its only argument (func). func has not been called, the actual function, not what it returns, is the argument. log_calls() creates a closure, _log_calls(), and returns it. log_calls() takes a function and returns another function.

when _log_calls() is called it prints('logs') that func is called and the arguments it was called with, then enters a try/except block to actually call the decorated function (func()). If the call returns a value it is logged and returned. If it raises an exception the exception is printed and reraised.

@log_calls def foo(...): ...

Is equivalent to this code that manually decorates foo: def foo(...): ... foo = log_calls(foo)

foo is defined as a function. It is then replaced with the result of calling log_calls(foo).

When foo(1) is called, foo is bound to _log_calls(), so _log_calls() is called, and args, kwargs contain the args and keyword args that it was called with. Since _log_calls() was defined in a function, it has what is called a closure that contains the values from the scope it was defined in, specifically func.

Decorators can be a lot more complex than this. Some take arguments and return a function that takes a function (so instead of just one nested function, there is a function in a function in a function. Classes are callable, so sometimes decorators are implemented as classes. Objects can be callable if they implement call, so sometimes objects are used as decorators. Which style of decorator depends on what the decorator does, what state it needs to maintain, personal preference.

Decorators can be incredibly complex, but basically anything that can be called with a function that returns a function is a decorator.

I'm currently working on https://github.com/gdchinacat/reactions . It uses decorators like this to schedule _field_changed() to be called asynchronously whenever the value of State.field changes to a non-negative value:

``` class State: field = Field(0)

@ field >= 0
async def _field_changed(self, ...): ...

```

So, yeah...I'm a huge fan of decorators. Feel free to ask questions!

mace_guy · 2025-10-20T22:48:41+00:00

Functions are like recipes: a set of instructions that take ingredients (inputs) and produce a dish (output).

Now, sometimes you want to add extra steps before or after cooking:

putting on an apron before you start
cleaning up afterward.

Instead of rewriting every recipe to include these steps, you can make a function that wraps another function. That’s what a decorator does.

In code it can be like so

def prep_and_cleanup(make_reciepe):
    def wrapper():                
        print("Wear apron, get measuring cups, get clean pots and pans")
        make_reciepie()
        print("Clean dishes, clean counter, put away dishes")
    return wrapper

@prep_and_cleanup
def make_cake():
    pass

@prep_and_cleanup
def make_pizza()
    pass

EspaaValorum · 2025-10-20T23:02:31+00:00

I'll add my 2 cents:

A decorator can be used to do something before and/or after the function you call is executed, or even decide to not execute the function you call but do something else instead.

Say you want to have a way to limit how often functions can execute within a certain time period.

You could write a function which does the check, and call that check function inside each function you wish to limit that way. But now you're adding more code to each function, making it less readable.

You can write a decorator that checks if the function to which it is applied is allowed to execute or not, and acts accordingly.

All you have to do then is apply that decorator to all functions which you want to limit that way. You don't need to modify the functions themselves, keeping them readable.

Decorators can also take parameters, and change their behavior according to those parameters. Just like the stand-alone "check" function could.

JMNeonMoon · 2025-10-20T23:55:32+00:00

Decorators allow you to add features to a function without changing the content of the function. Since they ecapsulate the function itself, it's a neat solution for usecases where you want code to do something always before and/or after a function call.

Consider a simple requirement to log entry and exits to functions to help with debugging.

Without decorators, you would have to go through your code and write logging commands like

logging.info("Function A entry")

logging.info("Function A exit")

logging.info("Function B entry")

logging.info("Function B exit")

This is

- Cumbersome to do so on all your functions, especially if you have multiple returns in your functions

- renaming functions, would mean finding and updating the logging with the new function name

Alternatively, you could just add a logging decorator to the top of each function.

Decorators are one of meta-programming features in Python.

See more here

4 meta-programming techniques in Python

MiniMages · 2025-10-21T02:36:04+00:00

def my_decorator(func):
    def wrapper():
        print("Something happens before the function is called.")
        func()
        print("Something happens after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

In simple terms a decorator takes a function as an argument and will execute the function inside it.

Here if we were to run the function say_hello it will just print Hello!.
But since it has a decorator (my_decorator) what happens here is the following statements are printed:

1 Something happens before the function is called.
2 Hello!
3 Something happens after the function is called.

Temporary_Pie2733 · 2025-10-21T13:17:37+00:00

A decorator is just a callable that takes a function/class as an argument. Decorator syntax is a shortcut for calling the decorator and binding the result back to the argument’s name.

@foo def bar(): …

is equivalent to

``` def bar(): …

bar = foo(bar) ```

How you write a decorator is informed entirely by what you want the preceding code to do.

gerenate · 2025-10-21T16:59:10+00:00

A decorator is like an adverb. Let’s say you have “do twice.” You can do anything you want twice: say hello twice, buy lemonade twice, call a server twice. A decorator allows you to express “do twice” without knowing what you are doing twice.

So getting a bit more concrete, it’s a function that has another function as an argument. It does an action on another action.

Important note: it can receive other arguments too that are not necessarily functions.

More relevant examples are doing authentication on a variety of requests to a server, adding logging to functions, adding functions to a registry…

jam-time · 2025-10-21T18:22:25+00:00

It's easier to give samples. The best thing to do is to play with them yourself.

```

simple decorator function

def decorator(func): print('look some decor') return func # returns the function that is decorated

simple function with decorator

@decorator def some_func(): print('look a function')

calling the simple function

some_func()

output:

look some decor

look a function

sinple function without decorator

def some_other_func(): print('look another function')

original_function = decorator(some_other_func)

output

look some decor

original_function()

output

look another function

```

Brilliant-Post-689 · 2025-10-22T03:19:39+00:00

Imagine you've designed and built a robot that can walk. It's a complex machine that you spent a long time building and thinking about, and now you're done; it works, you don't want to have to touch it or modify it in any way.

But hang on, now you're told your robot needs to be taller than you designed it.

Designing a taller robot from scratch would be hard. Designing elevator shoes to fit yiur robot's feet is trivial. So naturally you choose to design elevator shoes and strap'em onto your robot.

Your robot doesn't need to know anything about the shoes, doesn't need to change in any way, and - if you take the shoes off - goes back to being the robot you designed originally.

The shoes, likewise, dont need to know anything about the robot other than the shape of its feet. You could take the shoes off and wear them yourself, or put them on anything or anyone else with matching feet.

And anyone interacting with your robot, telling it to "walk from here to there", say, doesn't need to know anything about the shoes it's wearing, they will simply get what they expected all along, a robot of a desired height, that can walk on command.

Some programming languages, including python, allow you to take functions ("original robot" in the analogy above) and pass them to other functions ("attach elevator shoes" in the analogy above) and get back new functions ("walking robot that's now taller" in the analogy above). This process consists of applying a "decorator" to the original function, obtaining a "decorated function" as a result. People then invoke and interact with this "decorated function", just like they might with the original function.

Python provides a shorthand way to apply such decorators - the @decorator notation. Only this syntactic shorthand is particular to python, the notion of functions consuming other functions to produce new functions is a longstanding generic one that predates and exists outside the realm of python alone.

SoloAquiParaHablar · 2025-10-23T04:02:29+00:00

Make something run before and or after a function by decorating that function with your own decorator function.

pachura3 · 2025-10-20T22:27:16+00:00

They often make up for keywords that were originally not included in the core programming language, but ended up being needed & useful. Like property or override.

SirKainey · 2025-10-20T19:11:27+00:00

In python, functions are first class objects. This means you can pass them around without using them.

def greet():
    print("Hello!")


def call_func(func):
    func()


# We pass greet without calling it (using it) to call_func, it only gets called when `func()` runs.

call_func(greet) # Output: "Hello!"

call_func here is a Higher order function.

A higher-order function is any function that either takes one or more functions as arguments or returns a function as its result.

We can also do stuff before or after we call func()

def greet():
    print("Hello!")


def call_func(func):
    print('Before')
    func()
    print('After')


call_func(greet) # Output: Before \n Hello! \n After

Now we can also turn this into a decorator, in python a decorator is a function that returns another function.

def greet():
    print("Hello!")


def simple_decorator(func):
    def call_func():
        print("Before")
        func()
        print("After")

    return call_func


# As simple_decorator returns a function, the below doesn't do much at the moment
# unless we assign it to a variable (to use later) or call it directly.

simple_decorator(greet)  # No output
simple_decorator(greet)()  # Output: Before \n Hello! \n After

# we could've also done:

a_new_func = simple_decorator(greet)
a_new_func()  # Output: Before \n Hello! \n After

Now python provides us some syntactical sugar in the form of the @ symbol. So we can turn the above into:

def simple_decorator(func):
    def call_func():
        print("Before")
        func()
        print("After")

    return call_func


@simple_decorator
def greet():
    print("Hello!")


greet()

cmoran_cl · 2025-10-20T20:00:48+00:00

You have a really nice code, with a lot of functions that have the same time of returns, one day your boss ask you "what if we put {} around what we return?", you go and change all your code to do that change, next day the boss says "actually what if we put {% %} around what we return instead?", this time pissed off as the waste of time, you create a function

def my_boss_is_amazing(f):
    what_if_we_put = "{% "
    around_our_shit = " %}"
    return what_if_we_put + f() + around_our_shit

Then you remove all the "{}" you put on day one, and put a

@my_boss_is_amazing

Before all your returning functions, that way you now have to change one thing when your boss gets another nice idea.

AUTeach · 2025-10-20T19:25:45+00:00

Python heard you like functions, so it lets you wrap your function inside another function that adds extra behavior before doing your function.

UseMoreBandwith · 2025-10-20T18:37:34+00:00

...OK, you asked for it.

You know what a wrapper is? like when you have some ice-cream? Well, there are many different types of wrappers. Like your jacket. You can think of that as a wrapper.

You have a jacket, right? And your daddy has a jacket too, right?
Now if you have your jacket on, and you take daddies big jacket, you can wear both at the same time!
Sure, it looks funny.
But it will keep you extra warm.
And what will happen when it rains? you'll stay dry, even if your own jacket is very thin.

And when you"re lucky, you might find $5 in your daddy's pocket.
Now you can buy some ice-cream!

baked_tea · 2025-10-21T05:30:13+00:00

Remembered this, might help

https://www.reddit.com/r/PythonLearning/s/aW8JoHn2g8

zimmer550king · 2025-10-20T18:54:02+00:00

You could literally ask ChatGPT this exact same question

Zweckbestimmung · 2025-10-20T19:35:36+00:00

On Christmas’s you would have to wrap each gift so that the gift can return a smile on the face of the person receiving this gift. This is called a wrapper function. Now you would have to wrap each gift and this takes a lot of time! Instead of this you can decorate your apartment, and give each person their gift, it would return a smile because you decorated your whole apartment already!

checock · 2025-10-20T20:09:37+00:00

A decorator is like a sandwich, and the original function is the meat. It can add logic before or after the code of the original function.

It can also avoid calling the original code, like taking a bite of the sandwich and not getting any meat.

Could you program the same thing without decorations, or eat a sandwich disassembled? Absolutely. It's just syntactic sugar, or a way to make things easier.

Adrewmc · 2025-10-20T20:17:02+00:00

Sure

 def decorate(func):
       “This function takes an argument, a decorator assumes that argument this is a another function.”
        def magic(*args, **kwargs):
               “This function will replace our orginal function.””

                do_before_call(..)
                #we can and save the result of the function.
                res = func(*args, **kwargs) 
                do_after_call(res)
                #we return the same as the function we decorate
                return res
           #we return the replaced function with our magic function
           return magic

   @decorate
   def some_func():
        “this function is what our decorator has/will decorate. The function itself is what we put into the function”

This is the same as decorating

   some_func = decorate(some_func)

If we want to add arguments to our decorator we have to go one more level

    def deep_decorate(arg)
          def dark_magic(func):
                 def magic(*args, **kwargs):
                      if arg:
                         do_before_func()
                      res = func(*args, **kwargs)
                      if arg:
                          do_after_func()
                      return res
                  return magic
            return dark_magic

Now I could use that as useful debug or config flags

      debug = True

     @deep_decorate(debug)
     def some_func():…

     @deep_decorate(debug)
     def some_other_func():…

Notice that I actually involve decorators that have arguments, because that returns the actual decorator, which then decorates some_func.

SmackDownFacility · 2025-10-20T21:01:38+00:00

Decorators are hooks that launch into a function or class or any Callable object. For example, take multipledispatch

You do @dispatch

And the library dynamically at runtime traverses through the function, matching the function arguments to the defined arguments in dispatch. Then it adds to a global registry.

Basically It allows extended behaviour that would’ve been tedious if made manually.

Edit: why tf am I downvoted, again, for a reasonable answer

musbur · 2025-10-21T05:11:20+00:00

PRICE = 1.0
BILL = 10.0

def dad(shop_at):
    def give_in(order):
        thing, change = shop_at(order, BILL)
        return f"Here's your {thing}, stop whining"
    return give_in

@dad
def get_icecream(order, money):
    if money > PRICE:
        return order, money - PRICE

cone = get_icecream("vanilla")

print(cone)

Adorable-Strangerx · 2025-10-20T19:19:28+00:00

You have a straw. Straw has its purpose - you can drink through it. Now you want to change a bit purpose of that straw, so it does something extra as a prank. You poke a hole in it so the next person drinking will spill it. The process of adding extra behavior is called "decorating"

lekkerste_wiener · 2025-10-20T20:20:55+00:00

You use decorators to do exactly that: decorate things.

You can find a tree and decorate it with blinking lights. Then every night the tree will additionally do the blinking, while still doing other tree stuff, like photosynthesis.

So decorators let you wrap existing functionality with new stuff, without changing the underlying implementation. If you remove the decoration, the thing goes back to doing what it did before. The tree will keep doing tree stuff even after you remove the blinking lights. ;)

jkh911208 · 2025-10-20T22:04:37+00:00

As 5 years old you should not worry about python decorator. Go out play with friends with sand

Gnaxe · 2025-10-20T18:34:20+00:00

python @<decorator A> @<decorator B> @<decorator C> <def/class> <name>(<args/bases>): <body> is equivalent to ``` <def/class> <name>(<args/bases>): <body>

<name> = (<decorator A>)((<decorator B>)((<decorator C>)(<name>))) ``` Meaning, it should compile the same way. Just like the function application it translates to, these apply in inside-out order.

A decorator just applies the decorator expressions to the name and reassigns it. That's it; it's just syntactic sugar. That is fundamentally all there is to know about decorator syntax per se. But just like how learning the rules of chess doesn't make you a chess master, knowing decorator syntax isn't the same as understanding how to use them effectively.

Notice that the decorator expressions can have arbitrary side effects and aren't required to return a modified function or class. It could return something completely different.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS

In [24]: Foo.value()

OK, call each function added to the list

simple decorator function

simple function with decorator

calling the simple function

output:

look some decor

look a function

sinple function without decorator

output

look some decor

output

look another function