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()

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

In this example, my_decorator is a function that takes another function func as an argument. Inside my_decorator, a new function wrapper is defined that adds some behavior before and after calling func. The @my_decorator syntax is a shorthand way of applying the my_decorator to the say_hello function, which means that say_hello is now wrapped by my_decorator. When say_hello is called, it actually executes wrapper, which in turn calls say_hello along with the additional behavior defined in my_decorator.

Decorators are particularly useful in several scenarios:

• Code Reusability: When you have a piece of functionality that you want to apply to multiple functions or methods without duplicating code. Decorators allow you to wrap the common functionality and apply it to multiple functions easily.
• Cross-cutting Concerns: When you need to add functionality that is orthogonal to the main purpose of the function. For example, logging, authentication, authorization, caching, etc. These concerns can be implemented as decorators, keeping the core function clean and focused.
• Aspect-Oriented Programming (AOP): Decorators enable AOP by separating cross-cutting concerns from the main functionality of the program. This makes the code more modular and easier to maintain.
• Memoization: For implementing memoization, which is a technique used to speed up computations by caching the results of expensive function calls and returning the cached result when the same inputs occur again.
• Validation and Pre-processing: Decorators can be used to validate input parameters or preprocess data before a function is executed. This helps to keep the main function focused on its core logic.
• API Wrapping and Versioning: When working with APIs, decorators can be used to wrap functions with additional functionality such as error handling, rate limiting, or versioning.
• Functional Programming Techniques: Decorators are commonly used in functional programming paradigms to implement higher-order functions and function composition.

Overall, decorators are a versatile tool in Python that can be used in various situations to enhance code readability, modularity, and maintainability. However, it's important to use decorators judiciously and ensure that they enhance code clarity rather than making it more complex.