What is a Python decorator? How do you use one?

A Python decorator is a way to modify or extend the behavior of a function or method without directly changing its code. It is a special kind of function that takes another function as input, adds some functionality to it, and then returns the modified function.

Decorators are often used for things like logging, authentication, timing, or modifying function outputs.

---

How a Decorator Works:

1. A decorator is a function that wraps another function.
2. It takes the original function as an argument.
3. It returns a new function (or sometimes the same function) with the desired modifications.

---

Basic Syntax of a Decorator:

Using the @decorator_name syntax, you can easily apply a decorator to a function.

@decorator_name
def function_to_decorate():
    pass

The line @decorator_name is equivalent to writing:

function_to_decorate = decorator_name(function_to_decorate)

---

Example: Writing and Using a Decorator

Step 1: Write a Decorator

Here’s a simple decorator that adds logging:

def log_decorator(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

Step 2: Apply the Decorator

You can apply the decorator to a function using the @ syntax:

@log_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

Output:

Calling function: say_hello
Hello, Alice!
Function say_hello finished.

---

Why Use Decorators?

1. Code Reusability: Decorators let you reuse logic across multiple functions.
2. Clean Code: Keep the core function logic separate from additional behaviors.
3. DRY Principle: Avoid repetition (Don’t Repeat Yourself).

---

A Practical Example: Timing a Function

Here’s a decorator that measures how long a function takes to run:

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time:.2f} seconds to execute.")
        return result
    return wrapper

@timer_decorator
def compute_square(numbers):
    return [n ** 2 for n in numbers]

compute_square(range(1, 1000000))

---

Decorators with Arguments

If you want your decorator to take arguments, you need to add another level of nesting:

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

@repeat_decorator(times=3)
def greet():
    print("Hello!")

greet()

Output:

Hello!
Hello!
Hello!

---

Decorators are an essential feature in Python that can simplify code and add powerful functionality with minimal changes! Let me know if you’d like further clarification or more examples. 😊