Wraps a function to add pre‑ and post‑execution side effects (printing).

Illustrates the decorator pattern for adding behavior before and after a function call.

When you need to add logging, debugging, or other side‑effects around a function call without modifying its source.

Used in Python code where cross‑cutting concerns such as logging, timing, or authentication are applied to functions.

def <decorator_name>(func):\n def wrapper(*args, **kwargs):\n <before>\n result = func(*args, **kwargs)\n <after>\n return result\n return wrapper

def <decorator_name>(func):\n def wrapper(*args, **kwargs):\n <before>\n result = func(*args, **kwargs)\n <after>\n return result\n return wrapper

<decorator_name>: name of the decorator; <before>: code to run before calling func; <after>: code to run after; func: the function being wrapped; *args, **kwargs: function arguments.

• @my_decorator
• @logger
• @timer
• @wrapper
• @decorator

• replace print with logging.info
• add *args
• **kwargs to wrapper
• use functools.wraps to preserve metadata
• return result
• handle exceptions.

forgetting to return the wrapper; omitting *args/**kwargs causing errors on functions with arguments; swallowing exceptions; not returning the function result.

similar to functools.wraps, class‑based decorators, context managers; contrasted with plain function calls and inheritance‑based extension.

Omitting *args/**kwargs leads to TypeError when the wrapped function expects arguments; forgetting to return result makes the decorated function return None; not preserving __name__ and docstring can hinder debugging.

• Python decorators
• function wrappers
• decorator patterns

This simple decorator only works for functions without arguments; real‑world decorators must accept *args, **kwargs to be generic.

Signals that the decorated function is being instrumented for side effects such as logging or timing.

Prints 'before' and 'after' around a function call.

functools.wraps, class‑based decorators, decorators that accept arguments