Logs function invocation details for debugging or tracing purposes.

Communicates that a function is being called with specific arguments, aiding in debugging and tracing execution flow.

When a developer wants to trace function calls without modifying the original function's source code.

Used in debugging, profiling, logging frameworks, or any scenario where function call tracing is needed.

def logger(func):\n def wrapper(*args, **kwargs):\n print(f'Calling {func.__name__} with args={args}, kwargs={kwargs}')\n return func(*args, **kwargs)\n return wrapper

def logger(func):\n def wrapper(*args, **kwargs):\n print(f'Calling {func.__name__} with args={args}, kwargs={kwargs}')\n return func(*args, **kwargs)\n return wrapper

{"slot":"func","description":"The function to be wrapped and logged."} {"slot":"*args","description":"Positional arguments passed to the wrapped function."} {"slot":"**kwargs","description":"Keyword arguments passed to the wrapped function."}

• logger decorator wrapper *args **kwargs func.__name__ print

• {"slot":"func"
• "alternatives":["f"
• "func_to_log"
• "target"]} {"slot":"*args"
• "alternatives":["*args"
• "*params"]} {"slot":"**kwargs"
• "alternatives":["**kwargs"
• "**kwds"]}

Forgetting to return func(*args, **kwargs) which would break the wrapped function's return value. Using print instead of a proper logging framework in production code. Not preserving function metadata (e.g., __name__, __doc__) – can be fixed with functools.wraps.

{"chunk":"functools.wraps","contrast":"Preserves metadata of the wrapped function; logger does not unless wraps is used."} {"chunk":"property decorator","contrast":"Used for attribute access control, not for logging calls."} {"chunk":"contextmanager decorator","contrast":"Manages resource setup/teardown via __enter__/__exit__, not call logging."}

May interfere with functions that rely on introspection of their own arguments if args/kwargs are altered. Using print in production can clutter stdout; prefer the logging module.

• function decorator
• logging decorator
• wrapper pattern

The logger decorator is a simple debugging aid; for production logging, consider using the logging module and functools.wraps to preserve function metadata.

Enables transparent insertion of logging behavior without altering the original function's code, promoting separation of concerns.

Imagine a 'logger' as a spy that watches function calls and reports what it sees.

Remember to return the wrapper function; otherwise the decorator returns None.

Consider using functools.wraps and the logging module for a production-ready logging decorator.