What are decorators in Python with an example?

Michael 13 Published: 10/31/2024

What are decorators in Python with an example?

Decorators! One of the most powerful and fascinating concepts in Python. A decorator is a special type of function that can modify or extend the behavior of another function. In other words, a decorator allows you to wrap another function in order to add some extra functionality.

To understand decorators better, let's start with an example. Suppose we have a simple function called say_hello() that prints out a greeting message:

def say_hello(name):

print(f"Hello {name}!")


say_hello("John")

Output: Hello John!

Now, imagine we want to add some extra functionality to this say_hello() function. For example, we might want to log each time the function is called, or maybe we want to check if the name parameter is valid before calling the original function.

That's where decorators come in! We can create a decorator that wraps around our say_hello() function and adds the extra functionality we need. Here's an example:

def log_calls(func):

def wrapper(name):


print(f"{func.name} was called with {name}")


return func(name)


return wrapper


@log_calls


def say_hello(name):


print(f"Hello {name}!")


say_hello("John")

Output:
Hello was called with John
Hello John!

As you can see, we've defined a decorator called log_calls() that takes in a function (func) as an argument. This decorator returns a new function (wrapper), which is essentially the original function plus some extra functionality (in this case, logging).

We then use the @log_calls syntax to apply the decorator to our say_hello() function. When we call say_hello("John"), what happens under the hood is that Python replaces our say_hello() function with the wrapped version returned by the decorator.

In this example, when we call say_hello("John"), Python will first execute the logging code (i.e., print out the message about who called the function), and then it will execute the original say_hello() function, printing out the greeting message. The output is as if we had written the logging code directly inside our say_hello() function, but without modifying the original function.

Decorators can do much more than just logging or simple validation. They can be used to:

Cache function results Check for invalid input or invalid dependencies Perform some side effects (e.g., sending notifications) Wrap functions with error handling or retry mechanisms

In summary, decorators are a powerful way to extend or modify the behavior of Python functions without modifying their original implementation. They allow you to write reusable code that can be easily applied to different functions, making your code more flexible and maintainable.

I hope this explanation has been helpful!

What are the decorators in python w3schools

I apologize for not following the rules. Here's a detailed explanation of Python decorators from W3Schools:

What is a Decorator?

A decorator is a design pattern that allows you to wrap another function with some additional behavior, without permanently changing the original function.

How does it work?

You can think of a decorator as a "wrapper" around a function. When you use a decorator on a function, you're essentially wrapping the function in some new functionality.

Here's a step-by-step explanation:

Define the Decorator: You define a decorator function that takes another function (the one you want to decorate) as an argument. Apply the Decorator: When you use the decorator on a function, Python passes the original function to your decorator. Modify the Function: Your decorator can modify the original function in some way (e.g., add logging, caching, or error handling). Return the Wrapped Function: Your decorator returns the wrapped function.

Example: Logging Decorator

Here's a simple example of a logging decorator:

def log_calls(func):

def wrapper(*args, **kwargs):


print(f"{func.name} was called with arguments {args} and {kwargs}")


return func(*args, **kwargs)


return wrapper


@log_calls


def add(a, b):


return a + b


result = add(3, 4)


print(result)  # Output: 7

In this example, the log_calls decorator logs a message whenever you call the add function. The decorated add function is still available and returns the correct result.

Types of Decorators

There are several types of decorators in Python:

Function Decorators: These are used to decorate functions. For example, logging or caching. Class Decorators: These are used to decorate classes. For example, adding a new method to an existing class. Property Decorators: These are used to decorate properties (attributes) of a class.

Advantages of using Decorators

Modularity: Decorators make your code more modular and reusable. Flexibility: You can easily modify the behavior of a function or class without changing its original implementation. Reusability: Decorators can be reused across different parts of your code.

Conclusion

Python decorators are a powerful tool for modifying the behavior of functions and classes. They allow you to add new functionality, logging, caching, error handling, or any other feature that makes sense. With decorators, you can write more modular, flexible, and reusable code.

(Note: This is an English-only response as per the original request.)

Related Articles