Tired of Adding Print Statements Everywhere? Use Decorators for Effortless Logging!

Have you ever found yourself drowning in print() statements while debugging your Python code? You add logs before a function, inside it, after it—only to delete them all once the bug is fixed. What if there was a cleaner, reusable way to log function calls without cluttering your code?

Enter decorators—a powerful Python feature that lets you add logging (or any other behavior) to functions seamlessly. No more manual print() spam! Let’s explore how decorators can simplify debugging and make your code more maintainable.

Why Logging Matters (And Why Print Statements Fail)

Before diving into decorators, let’s talk about logging. Proper logging helps you:

✅ Track function calls (what was executed, with which arguments)
✅ Debug issues faster (instead of guessing where things broke)
✅ Monitor performance (how long a function took to run)

But if you rely on print(), you end up with:

• Messy code (logs mixed with logic)
• Temporary clutter (adding/deleting prints repeatedly)
• No consistency (different log formats everywhere)

Decorators solve this by letting you define logging once and reuse it anywhere.

How Decorators Work for Logging

A decorator is a function that wraps another function to extend its behavior. Here’s a simple logging decorator:

def log(func):
    def wrapper(*args, **kwargs):
        print(f'📝 Calling {func.__name__} with args: {args}, kwargs: {kwargs}')
        result = func(*args, **kwargs)  # Call the original function
        print(f'✅ {func.__name__} returned: {result}')
        return result
    return wrapper

Using the Decorator

Just add @log above any function:

@log
def add(a, b):
    return a + b

add(3, 5)

Output:

📝 Calling add with args: (3, 5), kwargs: {}
✅ add returned: 8

Now every call to add() is automatically logged—no manual print() needed!

Advanced Logging Decorator Tricks

1. Logging Execution Time

Want to know how long a function takes? Modify the decorator:

import time

def time_logger(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f'⏱️ {func.__name__} took {end_time - start_time:.2f}s')
        return result
    return wrapper

@time_logger
def slow_function():
    time.sleep(2)

slow_function()  # Output: ⏱️ slow_function took 2.00s

2. Conditional Logging (Only Log Errors)

Only log when something goes wrong:

def log_errors(func):
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f'❌ Error in {func.__name__}: {e}')
            raise  # Re-raise the exception
    return wrapper

@log_errors
def risky_operation(x):
    return 10 / x

risky_operation(0)  # Output: ❌ Error in risky_operation: division by zero

3. Logging to a File (Instead of Console)

Replace print() with file writing:

def log_to_file(func):
    def wrapper(*args, **kwargs):
        with open("logs.txt", "a") as f:
            f.write(f'Called {func.__name__} with {args}\n')
        return func(*args, **kwargs)
    return wrapper

When Should You Use Logging Decorators?

✔️ Debugging complex functions (see inputs/outputs without modifying code)
✔️ Performance monitoring (track slow functions)
✔️ Audit trails (record when critical functions run)
✔️ Error tracking (log exceptions automatically)

Final Thoughts: Stop Debugging the Hard Way!

Decorators turn logging from a tedious chore into a one-time setup. Instead of scattering print() everywhere, you:

1. Write the decorator once
2. Reuse it across functions
3. Keep your code clean

Try it today! Replace your next debug print() with a decorator and see the difference.

What’s your favorite logging trick? Share in the comments! 🚀