Decorators in Python are a versatile feature that allows modification or enhancement of function or class behavior without altering their original code. They operate as higher-order functions, taking a callable as input and returning a new callable, often using the @ syntax for application. This article presents ten practical custom decorators for common programming tasks.

1. Execution Time Measurement

Monitoring performance is critical for optimization. This decorator calculates and logs the runtime of a function to identify bottlenecks.

import time

def time_tracker(func):
    def inner(*args, **kwargs):
        begin = time.perf_counter()
        output = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} executed in {end - begin:.4f} seconds.")
        return output
    return inner

@time_tracker
def process_dataset():
    # Insert data processing logic here
    pass

2. Result Caching for Efficiency

Cache function outputs to avoid redundant computations, particular beneficial for expensive operations like recursive algorithms.

def cache_results(func):
    stored = {}
    def inner(*args):
        if args in stored:
            return stored[args]
        computed = func(*args)
        stored[args] = computed
        return computed
    return inner

@cache_results
def compute_fib(num):
    if num < 2:
        return num
    return compute_fib(num - 1) + compute_fib(num - 2)

3. Input Validation

Ensure data integrity by validating parameters before function execution, raising errors for invalid inputs.

def check_inputs(func):
    def inner(*args, **kwargs):
        # Implement validation checks
        if all_valid:
            return func(*args, **kwargs)
        else:
            raise ValueError("Input validation failed.")
    return inner

@check_inputs
def evaluate_dataset(data):
    # Data analysis code
    pass

4. Output Logging

Record function results to a file for debugging and monitoring purposes.

def log_output(func):
    def inner(*args, **kwargs):
        result = func(*args, **kwargs)
        with open("output_log.txt", "a") as file:
            file.write(f"{func.__name__}: {result}\n")
        return result
    return inner

@log_output
def compute_statistics(data):
    # Statistical calculations
    pass

5. Graceful Error Handling

Suppress exceptions to prevent workflow interruptions, logging errors for later review.

def handle_errors(func):
    def inner(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as err:
            print(f"Error in {func.__name__}: {err}")
            return None
    return inner

@handle_errors
def transform_data(data):
    # Data transformation steps
    pass

6. Output Quality Assurance

Validate function outputs against defined criteria to maintain data quality.

def verify_output(func):
    def inner(*args, **kwargs):
        output = func(*args, **kwargs)
        if meets_criteria(output):
            return output
        else:
            raise ValueError("Output does not meet required standards.")
    return inner

@verify_output
def sanitize_data(data):
    # Data cleaning operations
    pass

7. Retry Mechanism for Resilience

Automatically retry function execution upon failure, with configurable attempts and delays.

import time

def retry_operation(attempts, wait_time):
    def decorator(func):
        def inner(*args, **kwargs):
            for i in range(attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as err:
                    print(f"Attempt {i + 1} failed: {err}. Retrying after {wait_time} seconds.")
                    time.sleep(wait_time)
            raise Exception("Maximum retry attempts reached.")
        return inner
    return decorator

@retry_operation(attempts=4, wait_time=1)
def retrieve_api_data(url):
    # API interaction code
    pass

8. Automated Visualization

Generate plots automatically from function results to streamline data presentation.

import matplotlib.pyplot as plt

def auto_visualize(func):
    def inner(*args, **kwargs):
        result = func(*args, **kwargs)
        plt.figure()
        # Visualization code here
        plt.show()
        return result
    return inner

@auto_visualize
def analyze_and_plot(data):
    # Combined analysis and plotting
    pass

9. Debugging Aid

Prinnt input arguments to assist in troubleshooting complex functions.

def debug_info(func):
    def inner(*args, **kwargs):
        print(f"Debug: {func.__name__} called with args={args}, kwargs={kwargs}")
        return func(*args, **kwargs)
    return inner

@debug_info
def intricate_processing(data, cutoff=0.7):
    # Complex processing logic
    pass

10. Deprecation Warning

Issue warnings for outdated functions to guide users toward newer alternatives.

import warnings

def mark_deprecated(func):
    def inner(*args, **kwargs):
        warnings.warn(f"{func.__name__} is deprecated and may be removed in future releases.", DeprecationWarning)
        return func(*args, **kwargs)
    return inner

@mark_deprecated
def legacy_processing(data):
    # Older processing method
    pass