Unlock Python’s Magic: Master Decorators for Clean, Powerful Code

Everything Is an Object

In Python, functions are objects and can be passed as arguments. The article starts with simple examples that demonstrate calling functions passed as parameters.

<code>def say_english():
    print 'hello'

def say_chinese():
    print '你好'

say_english()           # hello
say_chinese()           # 你好

def greet(say):
    say()

greet(say_english)      # hello
greet(say_chinese)      # 你好
</code>

Decorator Pattern

A decorator wraps a target function to add behavior before and after its execution, such as opening and closing a database connection.

<code>def connect_db():
    print 'connect db'

def close_db():
    print 'close db'

def query_user():
    connect_db()
    print 'query the user'
    close_db()

query_user()            # connect db
                        # query the user
                        # close db
</code>

By passing a function object to another function, we can create a reusable decorator.

<code>def query_user():
    print 'query some user'

def query_data(query):
    connect_db()
    query()
    close_db()

query_data(query_user)
</code>

To avoid modifying existing calls, the decorator can return a wrapper function.

<code>def query_user():
    print 'query some user'

def query_data(query):
    """Define a decorator that returns a wrapper"""
    def wrapper():
        connect_db()
        query()
        close_db()
    return wrapper

# Apply the decorator without changing original calls
query_user = query_data(query_user)
query_user()
</code>

Syntax Sugar @

The @ symbol is Python’s syntactic sugar for applying a decorator.

<code>def query_data(query):
    def wrapper():
        connect_db()
        query()
        close_db()
    return wrapper

@query_data
def query_user():
    print 'query some user'

query_user()
</code>

Using @ is equivalent to assigning the result of the decorator call.

<code>@query_data

def query_user():
    print 'query some user'
</code>

<code>query_user = query_data(query_user)
</code>

Passing Arguments to Decorated Functions

Decorators can forward arguments to the original function by defining the wrapper with parameters.

<code>def query_data(query):
    def wrapper(count):
        connect_db()
        query(count)
        close_db()
    return wrapper

@query_data

def query_user(count):
    print 'query some user limit {count}'.format(count=count)

query_user(count=100)       # connect db
                            # query some user limit 100
                            # close db
</code>

Decorator Parameters (e.g., Flask‑style Routing)

Frameworks like Flask pass arguments to decorators (e.g., a URL pattern). This can be achieved by having a decorator factory that returns the actual decorator.

<code>def router(url):
    print 'router invoke url', url

    def query_data(query):
        print 'query_data invoke url', url

        def wrapper(count):
            connect_db()
            query(count)
            close_db()
        return wrapper
    return query_data

@router('/user')

def query_user(count):
    print 'query some user limit {count}'.format(count=count)

query_user(count=100)   # connect db
                        # query some user limit 100
                        # close db
</code>

The article demonstrates that the @ syntax is simply a readable shortcut for calling a decorator‑returning function and then applying the resulting decorator to the target function.