Learn Python Decorators: A Comprehensive Beginner's Guide

What is Python Decorators: A Beginner's Guide?

At its core, a decorator in Python is a design pattern that allows you to add new functionality to an existing object without modifying its structure. In Python, functions are first-class citizens, meaning they can be passed around, assigned to variables, and returned from other functions. Decorators leverage this by being functions that take another function as input, wrap it with some new behavior, and return the modified function. This wrapping process is achieved through closures and the @ syntax, which provides a clean and readable way to apply decorators. They are a form of metaprogramming, enabling code to act on other code.

Syntax & Structure

The syntax for decorators in Python is remarkably clean, thanks to the @ symbol. When you place @decorator_name directly above a function definition, Python automatically passes that function to decorator_name. The decorator then typically defines an inner 'wrapper' function. This wrapper function usually calls the original function (often with args and *kwargs to handle any arguments) and adds its own logic before or after the call. Finally, the decorator returns this wrapper function. The @ syntax is syntactic sugar; it's equivalent to calling the decorator function manually and assigning its return value back to the original function's name.

Real Interview Use Cases

Decorators are incredibly versatile. A common use case is logging function calls: you can create a decorator that logs the function name, arguments, and return value every time it's executed. Another frequent application is access control or authorization, where a decorator can check if a user has the necessary permissions before allowing a function to run. Performance measurement is also a great candidate; a decorator can time how long a function takes to execute and report it. Caching results of expensive function calls, input validation, and even implementing retry mechanisms for network requests are other practical scenarios where decorators shine, making code DRY (Don't Repeat Yourself).

Common Mistakes

Beginners often struggle with understanding how decorators modify the original function's metadata (like its name and docstring). If not handled correctly, the wrapper function replaces the original, leading to loss of information which can be problematic for debugging and introspection. Another pitfall is forgetting to return the wrapper function from the decorator, which means the decorated function will effectively become None. Misunderstanding how args and *kwargs work within the wrapper can also lead to errors when the decorated function expects specific arguments. Finally, applying multiple decorators incorrectly can lead to unexpected behavior due to the order of execution.

What Interviewers Ask

Interviewers often use decorators to test your understanding of Python's function-as-first-class-object nature and closures. Expect questions like 'Explain what a decorator is' or 'Write a decorator to log function calls.' They might ask you to implement a decorator that adds caching or checks user permissions. Be prepared to explain the @ syntax and how it relates to passing functions as arguments. Understanding how to preserve function metadata using functools.wraps is a key point interviewers look for. Demonstrating you can write clean, reusable decorator logic shows a strong grasp of Python's advanced features.

Code Examples

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

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

say_hello()

This is a basic decorator. `my_decorator` takes a function `func` as input. It defines an inner function `wrapper` that prints messages before and after calling the original `func`. The `@my_decorator` syntax above `say_hello` is shorthand for `say_hello = my_decorator(say_hello)`. When `say_hello()` is called, it actually executes the `wrapper` function.

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

@repeat(num_times=3)
def greet(name):
    print(f"Hello {name}")

greet("Alice")

This decorator, `repeat`, takes an argument `num_times`. It's a decorator factory because it returns the actual decorator (`decorator_repeat`). The inner `wrapper` function accepts arbitrary arguments (`*args`, `**kwargs`) and calls the decorated function `num_times`. This allows you to customize decorator behavior.

import functools

def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling function {func.__name__}...")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} finished.")
        return result
    return wrapper

@log_calls
def add(a, b):
    "Adds two numbers."
    return a + b

print(add(5, 3))
print(f"Function name: {add.__name__}")
print(f"Docstring: {add.__doc__}")

Without `functools.wraps(func)`, `add.__name__` would be 'wrapper' and `add.__doc__` would be None. `@functools.wraps(func)` copies the original function's metadata (like `__name__` and `__doc__`) to the wrapper function, which is crucial for debugging and introspection.

def requires_admin(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # In a real app, check user roles from a database or session
        is_admin = True # Simulate admin status
        if is_admin:
            return func(*args, **kwargs)
        else:
            print("Access denied: Admin privileges required.")
            return None
    return wrapper

@requires_admin
def delete_user(user_id):
    print(f"Deleting user {user_id}...")

delete_user(123)

This decorator checks if the current user has admin privileges before executing the decorated function. If `is_admin` were `False`, the function would not be called, and an access denied message would be shown. This pattern is common in web frameworks for protecting routes.

Frequently Asked Questions