2.1. Introduction to Decorators

A decorator in Python is a design pattern that allows you to modify the behavior of a function or class method without changing its source code. It’s a higher-order function that takes a function as input and returns a new function with added or altered behavior. Think of a decorator as a wrapper that "decorates" a function by extending or modifying its behavior.

A decorator is a tool in Python that allows programmers to enhance or change the behavior of functions or methods. Rather than edit the function's code directly, a decorator lets you wrap the original function, allowing you to insert additional functionality before and after the function executes. This is especially useful when you want to apply the same enhancement across multiple functions without repeating code. In essence, decorators can be thought of as add-ons or modifications to existing functions that enhance their capabilities.

Imagine you have a plain cake, which is your original function. A decorator is like icing that you add on top of the cake to enhance its flavor and appearance. You can have various kinds of icing like chocolate, vanilla, etc., representing different types of decorators that can modify the function's behavior in unique ways.

def my_decorator(func):
    def wrapper():
        print("Before the function runs")
        func()
        print("After the function runs")
    return wrapper

def say_hello():
    print("Hello!")

decorated_func = my_decorator(say_hello)
decorated_func()

Output: Before the function runs Hello! After the function runs

This example demonstrates how decorators operate. We define a decorator called my_decorator that takes a function (func) as an argument. Inside, we define a wrapper function that adds behavior before and after calling the original function. When my_decorator(say_hello) is called, it returns the wrapper function, which is then called to execute the code. The output shows that before and after the greeting 'Hello!', messages are printed, demonstrating how decorators can add functionality around existing code.

Think of a decorator as a security guard at a theater. Before anyone can enter (the function running), the guard checks tickets (the behavior before), and after the show, the guard ensures everyone exits in an orderly manner (the behavior after). The theatergoers, like the function say_hello, are allowed in only with these additional actions taking place.

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

This is equivalent to say_hello = my_decorator(say_hello).

The @ symbol is a more convenient way to apply decorators to functions. When you prefix a function definition with @my_decorator, Python automatically passes the function that follows it (say_hello) into the decorator, just as if you had called my_decorator(say_hello) manually. The end result is the same; the original function is replaced with the modified one that includes the decorator's enhancements. This syntax makes code clearer and allows for a cleaner definition of decorators in your code.

Think of it as a special VIP pass you clip onto an event ticket. When you present your ticket at the door, the staff instantly recognizes your VIP status because of the pass (the @ symbol). The staff grants you special privileges (the decorator’s added features) automatically without needing to show additional credentials every time.

--