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.

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

Using the @ syntax for decorators:

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

This is equivalent to say_hello = my_decorator(say_hello).

Decorators are widely used to add logging, access control, memoization, timing, and more.

Example: Logging Decorator

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args {args} and kwargs {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

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

add(3, 4)

Output:

Calling add with args (3, 4) and kwargs {}
add returned 7

Notice how the wrapper preserves the arguments and return value.

Sometimes decorators themselves need parameters. This requires an extra level of nested functions.

Example: Decorator with Arguments

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")
greet("Alice")

This produces:

Hello, Alice!
Hello, Alice!
Hello, Alice!

Explanation:
● repeat(3) returns decorator, which receives greet.
● decorator returns wrapper, which calls greet 3 times.

Decorators can also be applied to classes. They receive the class as an argument and can modify or replace it.

Example: Class Decorator that Adds an Attribute

def add_class_attr(cls):
    cls.extra_attribute = "Added by decorator"
    return cls

@add_class_attr
class MyClass:
    pass

print(MyClass.extra_attribute) # Output: Added by decorator

Example: Class Decorator That Wraps Methods

def method_logger(cls):
    for attr_name, attr_value in cls.__dict__.items():
        if callable(attr_value):
            setattr(cls, attr_name, logger(attr_value))
    return cls

@method_logger
class Calculator:
    def add(self, x, y):
        return x + y

calc = Calculator()
calc.add(5, 7)

This applies the earlier logger decorator to all methods.

Python provides some powerful built-in decorators that are commonly used to manage class behaviors.

2.5.1 @property
@property allows you to use methods like attributes. It’s a way to add getter, setter, and deleter methods in a Pythonic way.

class Circle:
    def __init__(self, radius):
        self._radius = radius
    @property
    def radius(self):
        return self._radius
    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError("Radius must be positive")
        self._radius = value
    @property
    def area(self):
        import math
        return math.pi * (self._radius ** 2)
c = Circle(5)
print(c.radius) # 5
print(c.area) # 78.53981633974483
c.radius = 10
print(c.area) # 314.1592653589793

Using @property improves encapsulation by allowing validation and calculation without changing the attribute access syntax.

2.5.2 @staticmethod
A static method is a method inside a class that does not operate on an instance or the class itself.

class Math:
    @staticmethod
    def add(x, y):
        return x + y
print(Math.add(3, 4)) # 7

Static methods are used for utility functions logically related to the class.

2.5.3 @classmethod
Class methods receive the class (cls) as the first argument and can modify class state.

class Person:
    population = 0
    def __init__(self, name):
        self.name = name
        Person.population += 1
    @classmethod
    def get_population(cls):
        return cls.population
p1 = Person("Alice")
p2 = Person("Bob")
print(Person.get_population()) # 2

What is a Descriptor?
A descriptor is an object attribute with “binding behavior,” meaning it defines methods to control attribute access. Descriptors are the low-level mechanism behind properties, methods, and more.

The descriptor protocol defines three methods:
● __get__(self, instance, owner) — Retrieve the attribute value.
● __set__(self, instance, value) — Set the attribute value.
● __delete__(self, instance) — Delete the attribute.

Descriptors are used as class variables. When accessed via an instance, Python calls the descriptor’s methods.

Example: Simple Descriptor

class Descriptor:
    def __get__(self, instance, owner):
        print("Getting attribute")
        return instance._value
    def __set__(self, instance, value):
        print("Setting attribute")
        instance._value = value
    def __delete__(self, instance):
        print("Deleting attribute")
        del instance._value
class MyClass:
    attr = Descriptor()
obj = MyClass()
obj.attr = 42 # Setting attribute
print(obj.attr) # Getting attribute, Output: 42
del obj.attr # Deleting attribute

Descriptors provide fine control over attribute access. Let’s create a descriptor that validates attribute values.

Example: Typed Attribute Descriptor

class Typed:
    def __init__(self, name, expected_type):
        self.name = name
        self.expected_type = expected_type
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self.name]
    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"Expected {self.expected_type}")
        instance.__dict__[self.name] = value
    def __delete__(self, instance):
        raise AttributeError("Can't delete attribute")
class Person:
    name = Typed('name', str)
    age = Typed('age', int)
    def __init__(self, name, age):
        self.name = name
        self.age = age
p = Person("Alice", 30)
print(p.name) # Alice
p.age = 31 # Works fine
# p.age = "Thirty" # Raises TypeError: Expected 

In this chapter, you learned:
● What decorators are, and how to use function, parameterized, and class decorators.
● Python’s built-in decorators @property, @staticmethod, and @classmethod for managing class behaviors.
● The descriptor protocol (get, set, delete), the foundation of attribute management in Python.
● How to create custom descriptors to add controlled, reusable attribute access logic such as validation and type checking.