What is a Python decorator?

A **Python decorator** is a special type of function that allows you to modify or enhance the behavior of another function or method without changing its actual code. Decorators provide a clean and readable way to "wrap" additional functionality around existing functions, making them very useful for tasks like logging, access control, memoization, timing, and more. ### How Decorators Work A decorator takes a function as an argument, defines an inner wrapper function that adds some behavior, and returns this wrapper. When you apply a decorator to a function using the `@decorator_name` syntax, the original function is replaced by the wrapper, which calls the original function internally but can execute extra code before or after it. ### Simple Example ```python def my_decorator(func): def wrapper(): print("Before the function runs") func() print("After the function runs") return wrapper @my_decorator def say_hello(): print("Hello!") say_hello() ``` **Output:** ``` Before the function runs Hello! After the function runs ``` In this example, `my_decorator` wraps the `say_hello` function. When you call `say_hello()`, it actually runs the `wrapper` function inside the decorator, which adds print statements before and after the original `say_hello` function call. ### Decorators with Arguments If the original function takes arguments, the wrapper should accept and pass them along using `*args` and `**kwargs`: ```python def repeat_decorator(func): def wrapper(*args, **kwargs): print("Repeating twice:") func(*args, **kwargs) func(*args, **kwargs) return wrapper @repeat_decorator def greet(name): print(f"Hello, {name}!") greet("Alice") ``` **Output:** ``` Repeating twice: Hello, Alice! Hello, Alice! ``` ### Summary - Decorators wrap functions to add or change behavior. - Use the `@decorator_name` syntax above a function definition to apply a decorator. - The wrapper function inside the decorator typically calls the original function. - They help keep your code modular, clean, and DRY (Don't Repeat Yourself). Decorators are a powerful feature in Python that can greatly simplify common programming patterns.

A **Python decorator** is a special type of function that is used to modify or enhance the behavior of other functions or methods without changing their actual code. Decorators allow you to wrap another function in order to extend its functionality in a clean, readable, and reusable way. ### How Decorators Work In Python, functions are first-class objects, meaning you can pass them around and use them as arguments. A decorator takes a function as input and returns a new function that adds some kind of functionality before or after the original function runs. Here's a simple example: ```python 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() ``` **Output:** ``` Something is happening before the function is called. Hello! Something is happening after the function is called. ``` In this example: - `my_decorator` is a decorator function. - It defines an inner function `wrapper` that adds behavior before and after calling the original function `func`. - The `@my_decorator` syntax is a shorthand for `say_hello = my_decorator(say_hello)`. - When `say_hello()` is called, it actually runs the `wrapper` function returned by the decorator. ### Common Uses of Decorators Decorators are often used for: - **Logging**: Automatically log function calls. - **Access control and authentication**: Check user permissions before executing a function. - **Memoization/caching**: Store results of expensive function calls. - **Timing**: Measure the time a function takes to execute. - **Input validation**: Verify function arguments. ### Decorators with Arguments If the decorated function takes arguments, the `wrapper` function inside the decorator needs to accept those arguments as well: ```python def decorator(func): def wrapper(*args, **kwargs): print("Before the function call") result = func(*args, **kwargs) print("After the function call") return result return wrapper @decorator def greet(name): print(f"Hello, {name}!") greet("Alice") ``` ### Summary Python decorators are a powerful and expressive tool that help you write cleaner code by abstracting common patterns of function modification, without cluttering the original function’s logic. They are widely used in frameworks like Flask and Django for routing, authentication, and more.