Who needs ’em, right? I mean, what’s the point of wrapping a function in another function when you can just call it directly? Well, my friend, let me tell ya decorators are where it’s at. They add an extra layer of functionality to your code without cluttering up your main functions with unnecessary lines.
So what exactly is a decorator? It’s a fancy term for wrapping one function around another. Let’s say you have this simple function:
# A decorator is a function that takes another function as an argument and returns a modified version of that function.
# Here is a simple function that prints "Hello, world!" when called.
def my_function():
print("Hello, world!")
# To create a decorator, we use the "@" symbol followed by the name of the decorator function.
# In this case, our decorator is called "decorator_function".
@decorator_function
def my_function():
print("Hello, world!")
# The decorator function takes in the original function as an argument.
# We can then define a new function within the decorator that adds extra functionality to the original function.
# In this case, we are simply printing a message before and after the original function is called.
def decorator_function(original_function):
def wrapper_function():
print("Before calling the original function.")
original_function()
print("After calling the original function.")
return wrapper_function
# To use the decorator, we simply call the original function as we normally would.
# However, the decorator function will be executed instead, adding the extra functionality.
my_function()
# Output:
# Before calling the original function.
# Hello, world!
# After calling the original function.
Now let’s add some spice to it with a decorator. Here’s an example of a basic decorator that adds a prefix to the output:
# This is a decorator function that adds a prefix to the output of the decorated function.
def prefix(func):
# This is a wrapper function that takes in any number of positional and keyword arguments.
def wrapper(*args, **kwargs):
# This line prints a test message before executing the decorated function.
print("This is a test!")
# This line calls the decorated function with the given arguments.
func(*args, **kwargs)
# This line returns the wrapper function.
return wrapper
# This is the decorated function that prints "Hello, world!".
@prefix
def my_function():
print("Hello, world!")
In this example, we’ve defined the `prefix()` decorator function that takes another function as an argument (the one to be decorated). The `wrapper()` function is a temporary function created inside of `prefix()`. This wrapper function will replace the original `my_function()` when it’s called.
The `@decorator` syntax is what makes decorators so powerful and easy to use. It allows us to apply multiple decorators to one function, which can be incredibly useful for adding complex functionality without cluttering up our code. For example:
# Importing the necessary module
from time import sleep
# Defining the decorator function
def timer(func):
# Defining the wrapper function that will replace the original function
def wrapper(*args, **kwargs):
# Recording the start time before the function is executed
start_time = time.time()
# Calling the original function with the given arguments and keyword arguments
result = func(*args, **kwargs)
# Recording the end time after the function is executed
end_time = time.time()
# Printing the time taken for the function to execute
print("Function took {:.2f} seconds to execute.".format(end_time - start_time))
# Returning the result of the original function
return result
# Returning the wrapper function to replace the original function
return wrapper
# Defining the prefix decorator function
def prefix(func):
# Defining the wrapper function that will replace the original function
def wrapper(*args, **kwargs):
# Adding a prefix to the output of the original function
print("Prefix: ", end="")
# Calling the original function with the given arguments and keyword arguments
result = func(*args, **kwargs)
# Returning the result of the original function
return result
# Returning the wrapper function to replace the original function
return wrapper
# Defining the original function
def my_function():
# Adding a delay of 3 seconds
sleep(3)
# Performing a simple calculation
5 + 7
# Applying the decorators to the original function
@timer
@prefix
def my_function():
# Printing a simple message
print("Hello, world!")
# Calling the decorated function
my_function()
# Output:
# Prefix: Hello, world!
# Function took 3.00 seconds to execute.
In this example, we’ve added two decorators to the `my_function()` function. The first is our custom `timer()` decorator that measures how long it takes for the function to execute and prints out the time taken at the end. The second is our original `prefix()` decorator from earlier.
They allow us to add functionality without cluttering up our code or creating unnecessary lines of boilerplate. Give ’em a try and see how they can improve your code!
But wait, what about those ***** side effects? Don’t worry, decorators have got you covered there too. By wrapping the function in another function, we can modify its behavior without changing its original implementation. For example:
# This script defines a decorator function called "log_function" that takes in a function as its argument.
# The purpose of this decorator is to log the function name, arguments, and keyword arguments before and after the function is executed.
def log_function(func): # Defines the decorator function "log_function" that takes in a function as its argument.
def wrapper(*args, **kwargs): # Defines a wrapper function that takes in any number of positional and keyword arguments.
print("Calling {} with args {} and kwargs {}".format(func.__name__, str(args), str(kwargs))) # Prints the function name, arguments, and keyword arguments before the function is executed.
result = func(*args, **kwargs) # Calls the original function with the given arguments and stores the result.
return result # Returns the result of the original function.
return wrapper # Returns the wrapper function.
# The decorator function is used by placing "@log_function" above the function definition.
# This will modify the behavior of the function by adding the logging functionality without changing its original implementation.
# For example:
@log_function # Uses the "log_function" decorator.
def add(x, y): # Defines a function called "add" that takes in two arguments.
return x + y # Returns the sum of the two arguments.
result = add(3, 5) # Calls the "add" function with the arguments 3 and 5 and stores the result.
print(result) # Prints the result, which is 8.
In this example, we’ve defined a `log_function()` decorator that logs the name of the function being called as well as its arguments and keyword arguments. This can be incredibly useful for debugging or tracking usage patterns in your code.
Give ’em a try and see how they can improve your code!