[SAMPLE] Understanding Python Decorators

Note: This is sample content to demonstrate the site’s tutorial format. It is not a real article.

Decorators are one of Python’s most powerful features, yet they often confuse newcomers. At their core, decorators are simply functions that modify other functions. Let’s explore how they work and when to use them.

What is a Decorator?

A decorator is a function that takes another function as input and returns a modified version of it. The syntax uses the @ symbol:

@decorator_name
def my_function():
    pass

This is equivalent to:

def my_function():
    pass
my_function = decorator_name(my_function)

A Simple Example

Here’s a basic decorator that logs function calls:

def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Finished {func.__name__}")
        return result
    return wrapper

@log_calls
def greet(name):
    return f"Hello, {name}!"

When you call greet("Alice"), you’ll see:

• Calling greet
• Finished greet
• Returns: "Hello, Alice!"

Practical Use Cases

Decorators shine in several scenarios:

• Caching: Store results of expensive function calls
• Authentication: Check user permissions before executing
• Timing: Measure function execution time
• Validation: Verify input parameters

Decorators with Arguments

You can also create decorators that accept arguments:

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def say_hello():
    print("Hello!")

The key is understanding the layers: the outer function takes your arguments, returns a decorator, which then decorates your function.

This is sample content for demonstration purposes only.