I'm not sure who this article is for, but I think it doesn't strike at the heart of the topic.

Half of the article is devoted to closures, but closures aren't essential for decorators. And the __closure__ attribute is an implementation detail that is really irrelevant. (For comparison, JavaScript has closures just like Python, but it doesn't expose the closed-over variables explicitly the way Python does.)

Decorators are simply higher order functions that are used to wrap functions. The syntax is a little funky, but all you need to know is that code like:

   @foo
   @bar
   def baz(args):
       return quux(args)

Is essentially equivalent to:

   baz = foo(bar(lambda args: quux(args))

...i.e. decorators are functions that take a callable argument and return a new callable (which typically does something and then calls the argument function--or not, as the case may be).

Then there are seemingly more complex expressions like:

    @foo(42, 'blub')
    def bar(..): ...

This looks like a special kind of decorator that takes arguments, but it looks more complex than it really is. Just like `foo` was an expression referencing a function `foo(42, 'blub')` is just a regular Python function call expression. That function call should then itself return a function, which takes a function argument to wrap the function being decorated. Okay, I admit that sounds pretty complex when I write it out like that, but if you implement it, it's again pretty simple:

    def foo(i, s):
        def decorator(f):
            def invoke(*args, **kwargs):
                print('decorator', i, s)
                f(*args, **kwargs)
                print('done')
        return invoke
    return decorator

    @foo(42, 'blub')
    def hello():
        print('Hello, world!')

    hello()

    # prints:
    #    decorator 42 blub
    #    Hello, world!
    #    done

This is an extra level of indirection but fundamentally still the same principle as without any arguments.

And yes, these examples use closures, which are very convenient when implementing decorators. But they aren't essential. It's perfectly possible to declare a decorator this way:

    class Invoker:
        def __init__(self, f):
            self.f = f
    
        def __call__(self):
            print('before call')
            self.f()
            print('after call')
    
    def decorator(f):
        return Invoker(f)
        
    @decorator
    def hello():
        print('Hello, world!')

    hello()
    # prints:
    #     before call
    #     Hello, world!
    #     after call

It's the same thing but now there are no closures whatsoever involved.

The key point in all these examples is that functions in Python are first-class objects that can be referenced by value, invoked dynamically, passed as arguments to functions, and returned from functions. Once you understand that, it's pretty clear that a decorator is simply a wrapper that takes a function argument and returns a new function to replace it, usually adding some behavior around the original function.