What are Python Decorators?
A decorator in Python is a higher-order function that allows you to modify or extend the behavior of another function without changing its actual code. Decorators are widely used in logging, authentication, caching, and other programming tasks.
Why Use Python Decorators?
✅ Enhances Functionality – Modify functions dynamically
✅ Code Reusability – Write reusable wrappers for multiple functions
✅ Keeps Code Clean – Avoids repetitive logic in multiple places
Basic Syntax of a Decorator
def decorator_function(original_function):
def wrapper_function():
print("Wrapper executed before", original_function.__name__)
return original_function()
return wrapper_function
Step-by-Step Guide with Examples
1. Creating a Simple Decorator
✅ Example: A Basic Decorator That Logs Function Execution
def log_decorator(func):
def wrapper():
print(f"Calling function: {func.__name__}")
func()
print(f"Function {func.__name__} executed successfully")
return wrapper
@log_decorator
def say_hello():
print("Hello, World!")
say_hello()
Output:
💡 Best Practice: Always use meaningful decorator names that describe their purpose.
2. Using Decorators with Arguments
✅ Example: Decorator for Timing Function Execution
import time
def timing_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} executed in {end_time - start_time:.4f} seconds")
return result
return wrapper
@timing_decorator
def slow_function():
time.sleep(2)
print("Function completed")
slow_function()
Output:
💡 Best Practice: Use *args and **kwargs in the wrapper function to handle functions with arguments.
3. Applying Multiple Decorators
✅ Example: Combining Logging and Execution Timing Decorators
def log_decorator(func):
def wrapper(*args, **kwargs):
print(f"Executing {func.__name__}()")
return func(*args, **kwargs)
return wrapper
def timing_decorator(func):
import time
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"{func.__name__}() took {end - start:.4f} seconds")
return result
return wrapper
@log_decorator
@timing_decorator
def greet(name):
print(f"Hello, {name}!")
greet("Alice")
Output:
💡 Best Practice: The order of decorators matters. The decorator closest to the function executes first.
4. Creating a Parameterized Decorator
✅ Example: A Decorator That Accepts Arguments
def repeat(times):
def decorator(func):
def wrapper(*args, **kwargs):
for _ in range(times):
func(*args, **kwargs)
return wrapper
return decorator
@repeat(3)
def greet():
print("Hello!")
greet()
Output:
💡 Best Practice: Use an inner function inside the decorator to handle arguments dynamically.
5. Using functools.wraps to Preserve Function Metadata
By default, decorators modify the function name and docstring. The functools.wraps module preserves the original function’s metadata.
✅ Example:
import functools
def log_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"Executing {func.__name__}")
return func(*args, **kwargs)
return wrapper
@log_decorator
def add(a, b):
"""Returns the sum of two numbers."""
return a + b
print(add.__name__) # Output: add
print(add.__doc__) # Output: Returns the sum of two numbers.
💡 Best Practice: Always use @functools.wraps(func) in decorators to avoid losing function metadata.
Real-World Applications of Decorators
✔ Logging Function Calls – Automatically log when a function is executed
✔ Caching Results – Store previous results to improve performance
✔ Authentication – Restrict access to functions based on user roles
✔ Performance Monitoring – Measure execution time of functions
When to Use Decorators?
✅ When modifying function behavior without changing the function’s code
✅ When applying reusable wrappers like logging, authentication, or timing
✅ When you need cleaner and more maintainable code
🚫 Avoid using decorators for simple cases where a direct function call works just fine.